Flyology_SIMD

Search API names

Description

Portable, fixed-width SIMD values and operations.

The scalar implementation defines the result of every operation. Optimized backends preserve those semantics behind private vector and mask types. Lane zero is the first logical element loaded from memory.

Add

function Add (Left, Right : F32x4) return F32x4

Add corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fadd instruction over 4s lanes. The x86-64 backend uses the SSE2 addps instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add

function Add (Left, Right : F64x2) return F64x2

Add corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fadd instruction over 2d lanes. The x86-64 backend uses the SSE2 addpd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I16x8) return I16x8

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqadd instruction over 8h lanes. The x86-64 backend uses one SSE2 paddsw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I32x4) return I32x4

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqadd instruction over 4s lanes. The x86-64 backend uses an SSE2 sequence that derives a signed-overflow mask and selects the signed minimum or maximum. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I64x2) return I64x2

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqadd instruction over 2d lanes. The x86-64 backend uses an SSE2 sequence that derives a signed-overflow mask and selects the signed minimum or maximum. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : I8x16) return I8x16

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqadd instruction over 16b lanes. The x86-64 backend uses one SSE2 paddsb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U16x8) return U16x8

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqadd instruction over 8h lanes. The x86-64 backend uses one SSE2 paddusw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U32x4) return U32x4

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqadd instruction over 4s lanes. The x86-64 backend uses an SSE2 sequence that derives a carry mask and selects the unsigned maximum. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U64x2) return U64x2

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqadd instruction over 2d lanes. The x86-64 backend uses an SSE2 sequence that derives a carry mask and selects the unsigned maximum. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Saturate

function Add_Saturate (Left, Right : U8x16) return U8x16

Add corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqadd instruction over 16b lanes. The x86-64 backend uses one SSE2 paddusb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I16x8) return I16x8

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 8h lanes. The x86-64 backend uses the SSE2 paddw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I32x4) return I32x4

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 4s lanes. The x86-64 backend uses the SSE2 paddd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I64x2) return I64x2

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 2d lanes. The x86-64 backend uses the SSE2 paddq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : I8x16) return I8x16

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 16b lanes. The x86-64 backend uses the SSE2 paddb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U32x4) return U32x4

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 4s lanes. The x86-64 backend uses the SSE2 paddd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U64x2) return U64x2

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 2d lanes. The x86-64 backend uses the SSE2 paddq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Add_Wrap

function Add_Wrap (Left, Right : U8x16) return U8x16

Add corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON add instruction over 16b lanes. The x86-64 backend uses the SSE2 paddb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

All_True

function All_True (Mask : Mask_16x8) return Boolean

Return true when every mask lane is true. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

All_True

function All_True (Mask : Mask_32x4) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

All_True

function All_True (Mask : Mask_64x2) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

All_True

function All_True (Mask : Mask_8x16) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_16x8) return Boolean

Return true when at least one mask lane is true. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_32x4) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_64x2) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

Any_True

function Any_True (Mask : Mask_8x16) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F32x4) return I32x4

Reinterpret every lane's bits without changing its lane position. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends reinterpret the complete 128-bit private vector value directly with Ada.Unchecked_Conversion. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F32x4) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F64x2) return I64x2

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : F64x2) return U64x2

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I16x8) return U16x8

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I32x4) return F32x4

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I32x4) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I64x2) return F64x2

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I64x2) return U64x2

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : I8x16) return U8x16

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U16x8) return I16x8

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U32x4) return F32x4

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U32x4) return I32x4

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U64x2) return F64x2

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U64x2) return I64x2

Parameters

Value: The input value.

Return value

The operation result.

Bit_Cast

function Bit_Cast (Value : U8x16) return I8x16

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I16x8) return I16x8

Apply bitwise AND to corresponding integer lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON and instruction over 16b. The x86-64 backend uses one SSE2 pand instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I64x2) return I64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : I8x16) return I8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U64x2) return U64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_And

function Bitwise_And (Left, Right : U8x16) return U8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I16x8) return I16x8

Complement every bit in every integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON mvn instruction over 16b. The x86-64 backend uses one SSE2 pcmpeqd instruction to construct all-one bits, followed by one pxor instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I32x4) return I32x4

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I64x2) return I64x2

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : I8x16) return I8x16

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U16x8) return U16x8

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U32x4) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U64x2) return U64x2

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Not

function Bitwise_Not (Value : U8x16) return U8x16

Parameters

Value: The input value.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I16x8) return I16x8

Apply bitwise OR to corresponding integer lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON orr instruction over 16b. The x86-64 backend uses one SSE2 por instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I64x2) return I64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : I8x16) return I8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U64x2) return U64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Or

function Bitwise_Or (Left, Right : U8x16) return U8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I16x8) return I16x8

Apply bitwise exclusive OR to corresponding integer lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON eor instruction over 16b. The x86-64 backend uses one SSE2 pxor instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I64x2) return I64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : I8x16) return I8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U64x2) return U64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Bitwise_Xor

function Bitwise_Xor (Left, Right : U8x16) return U8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Byte_Array

type Byte_Array is array (Natural range <>) of aliased U8;

Public lane, array, vector, or mask type Byte_Array.

Compress

function Compress (Value : F32x4; Mask : Mask_32x4) return F32x4

Stably pack lanes whose mask lane is true toward lane zero. Preserve their complete bit encodings and fill the remaining lanes with zero. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses fixed-width Ada code to derive a stable compression byte map from the mask, followed by a dedicated NEON tbl sequence. The x86-64 backend uses fixed-width Ada code to derive a stable compression byte map from the mask, followed by a dedicated SSE2 sequence that compares every byte selector with each valid source position, broadcasts matching source bytes, and merges them into the result. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : F64x2; Mask : Mask_64x2) return F64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I16x8; Mask : Mask_16x8) return I16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I32x4; Mask : Mask_32x4) return I32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I64x2; Mask : Mask_64x2) return I64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : I8x16; Mask : Mask_8x16) return I8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U16x8; Mask : Mask_16x8) return U16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U32x4; Mask : Mask_32x4) return U32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U64x2; Mask : Mask_64x2) return U64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Compress

function Compress (Value : U8x16; Mask : Mask_8x16) return U8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : I32x4) return F32x4

With the default round-to-nearest, ties-to-even environment, convert each integer lane to the corresponding floating-point lane. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON instruction that converts the integer lanes to floating-point lanes. The x86-64 backend converts the lanes with the dedicated SSE2 cvtdq2ps instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : I64x2) return F64x2

With the default round-to-nearest, ties-to-even environment, convert each integer lane to the corresponding floating-point lane. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON instruction that converts both integer lanes. The x86-64 backend converts each signed lane with cvtsi2sdq and merges the two binary64 results. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : U32x4) return F32x4

With the default round-to-nearest, ties-to-even environment, convert each integer lane to the corresponding floating-point lane. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON instruction that converts the integer lanes to floating-point lanes. Under the required default round-to-nearest, ties-to-even mode, the x86-64 backend adjusts unsigned values above the signed maximum. It then converts the lanes with cvtdq2ps. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Round

function Convert_Round (Value : U64x2) return F64x2

With the default round-to-nearest, ties-to-even environment, convert each integer lane to the corresponding floating-point lane. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON instruction that converts both integer lanes. Under the required default round-to-nearest, ties-to-even mode, the x86-64 backend shifts each unsigned value above the signed maximum to the right by one bit and preserves its discarded low bit. It converts the adjusted value with cvtsi2sdq and doubles the binary64 result. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I16x8) return U16x8

Convert each signed lane to the same-width unsigned lane. A negative input becomes zero. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-zero and smax.8h clamp sequence. The x86-64 backend uses an SSE2 pcmpgtw sign-mask and pandn clamp sequence. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I32x4) return U32x4

Convert each signed lane to the same-width unsigned lane. A negative input becomes zero. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-zero and smax.4s clamp sequence. The x86-64 backend uses an SSE2 pcmpgtd sign-mask and pandn clamp sequence. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I64x2) return U64x2

Convert each signed lane to the same-width unsigned lane. A negative input becomes zero. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON cmge.2d nonnegative mask followed by and.16b. The x86-64 backend uses an SSE2 psrad sign-mask and pandn clamp sequence. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : I8x16) return U8x16

Convert each signed lane to the same-width unsigned lane. A negative input becomes zero. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-zero and smax.16b clamp sequence. The x86-64 backend uses an SSE2 pcmpgtb sign-mask and pandn clamp sequence. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U16x8) return I16x8

Convert each unsigned lane to the same-width signed lane. An input above the signed maximum becomes that maximum. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-all-ones and ushr.8h signed-maximum construction followed by umin.8h. The x86-64 backend uses an SSE2 pcmpgtw, psrlw, pandn, and por sequence that constructs and selects the signed maximum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U32x4) return I32x4

Convert each unsigned lane to the same-width signed lane. An input above the signed maximum becomes that maximum. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-all-ones and ushr.4s signed-maximum construction followed by umin.4s. The x86-64 backend uses an SSE2 pcmpgtd, psrld, pandn, and por sequence that constructs and selects the signed maximum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U64x2) return I64x2

Convert each unsigned lane to the same-width signed lane. An input above the signed maximum becomes that maximum. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-all-ones and ushr.2d signed-maximum construction followed by cmhi.2d and bsl.16b selection. The x86-64 backend uses an SSE2 psrad, psrlq, pandn, and por sequence that constructs and selects the signed maximum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Saturate

function Convert_Saturate (Value : U8x16) return I8x16

Convert each unsigned lane to the same-width signed lane. An input above the signed maximum becomes that maximum. Other values and all lane positions are preserved. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON movi-all-ones and ushr.16b signed-maximum construction followed by umin.16b. The x86-64 backend uses an SSE2 pcmpgtb, psrlw, pandn, and por sequence that constructs and selects the signed maximum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F32x4) return I32x4

Truncate each floating-point lane toward zero, then clamp it to the integer result range. A NaN becomes zero. The operation does not depend on or modify the floating-point rounding mode. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that truncates floating-point lanes toward zero. It selects zero for NaN, the signed maximum for positive overflow, and the signed minimum for negative overflow. The x86-64 backend truncates the lanes with cvttps2dq. It selects zero for NaN, the signed maximum for positive overflow, and the signed minimum for negative overflow. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F32x4) return U32x4

Truncate each floating-point lane toward zero, then clamp it to the integer result range. A NaN becomes zero. The operation does not depend on or modify the floating-point rounding mode. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that truncates floating-point lanes toward zero. It selects zero for NaN or a negative input and the unsigned maximum for positive overflow. The x86-64 backend truncates the lanes with cvttps2dq. It selects zero for NaN or a negative input and the unsigned maximum for positive overflow. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F64x2) return I64x2

Truncate each floating-point lane toward zero, then clamp it to the integer result range. A NaN becomes zero. The operation does not depend on or modify the floating-point rounding mode. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that truncates floating-point lanes toward zero. It selects zero for NaN, the signed maximum for positive overflow, and the signed minimum for negative overflow. The x86-64 backend truncates each lane with cvttsd2siq and classifies the binary64 encoding to select zero or a signed range limit. It selects zero for NaN, the signed maximum for positive overflow, and the signed minimum for negative overflow. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Convert_Truncate_Saturate

function Convert_Truncate_Saturate (Value : F64x2) return U64x2

Truncate each floating-point lane toward zero, then clamp it to the integer result range. A NaN becomes zero. The operation does not depend on or modify the floating-point rounding mode. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that truncates floating-point lanes toward zero. It selects zero for NaN or a negative input and the unsigned maximum for positive overflow. For a value that is at least 2 to the power of 63 and less than 2 to the power of 64, the x86-64 backend subtracts 2 to the power of 63, truncates with cvttsd2siq, and restores the destination high bit. It classifies the binary64 encoding to select zero or the unsigned maximum. It selects zero for NaN or a negative input and the unsigned maximum for positive overflow. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : F32x4) return F32x4

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 4s lanes. The x86-64 backend uses SSE2 pshufd with control 0x88, followed by punpcklqdq. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : F64x2) return F64x2

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I16x8) return I16x8

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 8h lanes. The x86-64 backend uses SSE2 pshuflw and pshufhw with control 0x88, followed by pshufd and punpcklqdq. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I64x2) return I64x2

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : I8x16) return I8x16

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 16b lanes. The x86-64 backend uses SSE2 low-byte masking and packuswb. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U16x8) return U16x8

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 8h lanes. The x86-64 backend uses SSE2 pshuflw and pshufhw with control 0x88, followed by pshufd and punpcklqdq. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U64x2) return U64x2

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Even

function Deinterleave_Even (Left, Right : U8x16) return U8x16

Collect even lanes from the left input, then even lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp1 instruction over 16b lanes. The x86-64 backend uses SSE2 low-byte masking and packuswb. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : F32x4) return F32x4

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 4s lanes. The x86-64 backend uses SSE2 pshufd with control 0xDD, followed by punpcklqdq. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : F64x2) return F64x2

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpckhqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I16x8) return I16x8

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 8h lanes. The x86-64 backend uses SSE2 pshuflw and pshufhw with control 0xDD, followed by pshufd and punpcklqdq. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I64x2) return I64x2

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpckhqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : I8x16) return I8x16

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 16b lanes. The x86-64 backend uses SSE2 word shifts and packuswb. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U16x8) return U16x8

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 8h lanes. The x86-64 backend uses SSE2 pshuflw and pshufhw with control 0xDD, followed by pshufd and punpcklqdq. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U64x2) return U64x2

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpckhqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Deinterleave_Odd

function Deinterleave_Odd (Left, Right : U8x16) return U8x16

Collect odd lanes from the left input, then odd lanes from the right input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uzp2 instruction over 16b lanes. The x86-64 backend uses SSE2 word shifts and packuswb. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Divide

function Divide (Left, Right : F32x4) return F32x4

Divide corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fdiv instruction over 4s lanes. The x86-64 backend uses the SSE2 divps instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Divide

function Divide (Left, Right : F64x2) return F64x2

Divide corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fdiv instruction over 2d lanes. The x86-64 backend uses the SSE2 divpd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmeq comparison over 4s lanes for the equality predicate. The x86-64 backend uses the SSE2 cmpeqps comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmeq comparison over 2d lanes for the equality predicate. The x86-64 backend uses the SSE2 cmpeqpd comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 8h lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqw comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 4s lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqd comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 2d lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqd comparison with adjacent dword results combined per 64-bit lane for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 16b lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqb comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 8h lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqw comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 4s lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqd comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 2d lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqd comparison with adjacent dword results combined per 64-bit lane for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Equal

function Equal (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes for equality. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmeq comparison over 16b lanes for the equality predicate. The x86-64 backend uses the SSE2 pcmpeqb comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Expand

function Expand (Value : F32x4; Mask : Mask_32x4) return F32x4

Place consecutive low input lanes into result lanes whose mask lane is true. Preserve their complete bit encodings and fill false lanes with zero. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses fixed-width Ada code to derive an expansion byte map from the mask, followed by a dedicated NEON tbl sequence. The x86-64 backend uses fixed-width Ada code to derive an expansion byte map from the mask, followed by a dedicated SSE2 sequence that compares every byte selector with each valid source position, broadcasts matching source bytes, and merges them into the result. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : F64x2; Mask : Mask_64x2) return F64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I16x8; Mask : Mask_16x8) return I16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I32x4; Mask : Mask_32x4) return I32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I64x2; Mask : Mask_64x2) return I64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : I8x16; Mask : Mask_8x16) return I8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U16x8; Mask : Mask_16x8) return U16x8

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U32x4; Mask : Mask_32x4) return U32x4

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U64x2; Mask : Mask_64x2) return U64x2

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Expand

function Expand (Value : U8x16; Mask : Mask_8x16) return U8x16

Parameters

Value: The input value.
Mask: The input mask.

Return value

The operation result.

Extract

function Extract (Value : F32x4; Lane : Lane_Index_32x4) return F32

Return one logical lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends read the selected position from private vector storage directly with fixed-width Ada code. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : F64x2; Lane : Lane_Index_64x2) return F64

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I16x8; Lane : Lane_Index_16x8) return I16

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I32x4; Lane : Lane_Index_32x4) return I32

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I64x2; Lane : Lane_Index_64x2) return I64

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : I8x16; Lane : Lane_Index_8x16) return I8

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U16x8; Lane : Lane_Index_16x8) return U16

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U32x4; Lane : Lane_Index_32x4) return U32

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U64x2; Lane : Lane_Index_64x2) return U64

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

Extract

function Extract (Value : U8x16; Lane : Lane_Index_8x16) return U8

Parameters

Value: The input value.
Lane: The logical lane index.

Return value

The operation result.

F32

subtype F32 is Interfaces.IEEE_Float_32;

Public lane, array, vector, or mask type F32.

F32_Array

type F32_Array is array (Natural range <>) of aliased F32;

Public lane, array, vector, or mask type F32_Array.

F32x4

type F32x4 is private;

Public lane, array, vector, or mask type F32x4.

F64

subtype F64 is Interfaces.IEEE_Float_64;

Public lane, array, vector, or mask type F64.

F64_Array

type F64_Array is array (Natural range <>) of aliased F64;

Public lane, array, vector, or mask type F64_Array.

F64x2

type F64x2 is private;

Public lane, array, vector, or mask type F64x2.

First_True

function First_True (Mask : Mask_16x8) return Lane_Count_16x8

Return the first true lane, or the lane-count value when no lane is true. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated bit-reversal and leading-zero-count sequence to find the first set compact-mask bit. The x86-64 backend uses a dedicated bit-scan-forward sequence to find the first set compact-mask bit. Both return the lane-count value for a zero mask. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

First_True

function First_True (Mask : Mask_32x4) return Lane_Count_32x4

Parameters

Mask: The input mask.

Return value

The operation result.

First_True

function First_True (Mask : Mask_64x2) return Lane_Count_64x2

Parameters

Mask: The input mask.

Return value

The operation result.

First_True

function First_True (Mask : Mask_8x16) return Lane_Count_8x16

Parameters

Mask: The input mask.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_8x16) return U8x16

Construct a vector from lanes in logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends copy the supplied lane array into private vector storage directly with fixed-width Ada code. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_F32x4) return F32x4

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_F64x2) return F64x2

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I16x8) return I16x8

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I32x4) return I32x4

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I64x2) return I64x2

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_I8x16) return I8x16

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U16x8) return U16x8

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U32x4) return U32x4

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

From_Lanes

function From_Lanes (Values : Lane_Values_U64x2) return U64x2

Parameters

Values: Lane values in logical lane order.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmge comparison over 4s lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 cmpleps with reversed operands comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmge comparison over 2d lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 cmplepd with reversed operands comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 8h lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison merged with pcmpeqw equality for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 4s lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison merged with pcmpeqd equality for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 2d lanes for the greater-than-or-equal predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 16b lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison merged with pcmpeqb equality for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 8h lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison with an unsigned sign-bit bias merged with pcmpeqw equality for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 4s lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison with an unsigned sign-bit bias merged with pcmpeqd equality for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 2d lanes for the greater-than-or-equal predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Equal

function Greater_Equal (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 16b lanes for the greater-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison with an unsigned sign-bit bias merged with pcmpeqb equality for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmgt comparison over 4s lanes for the greater-than predicate. The x86-64 backend uses the SSE2 cmpltps with reversed operands comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmgt comparison over 2d lanes for the greater-than predicate. The x86-64 backend uses the SSE2 cmpltpd with reversed operands comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 8h lanes for the greater-than predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 4s lanes for the greater-than predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 2d lanes for the greater-than predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 16b lanes for the greater-than predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 8h lanes for the greater-than predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 4s lanes for the greater-than predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 2d lanes for the greater-than predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Greater_Than

function Greater_Than (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 16b lanes for the greater-than predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Has_Extent

function Has_Extent
  (Data : Byte_Array; Start : Natural; Count : Natural) return Boolean

Return true when Count byte elements fit in Data starting at Start. A zero Count requires no valid address. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Horizontal_Sum

function Horizontal_Sum (Value : U8x16) return Natural

Return the exact sum of all unsigned byte lanes as Natural. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uaddlv instruction to sum all 16 unsigned byte lanes. The x86-64 backend uses SSE2 psadbw to form two 64-bit partial sums and adds them. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

I16

subtype I16 is Interfaces.Integer_16;

Public lane, array, vector, or mask type I16.

I16_Array

type I16_Array is array (Natural range <>) of aliased I16;

Public lane, array, vector, or mask type I16_Array.

I16x8

type I16x8 is private;

Public lane, array, vector, or mask type I16x8.

I32

subtype I32 is Interfaces.Integer_32;

Public lane, array, vector, or mask type I32.

I32_Array

type I32_Array is array (Natural range <>) of aliased I32;

Public lane, array, vector, or mask type I32_Array.

I32x4

type I32x4 is private;

Public lane, array, vector, or mask type I32x4.

I64

subtype I64 is Interfaces.Integer_64;

Public lane, array, vector, or mask type I64.

I64_Array

type I64_Array is array (Natural range <>) of aliased I64;

Public lane, array, vector, or mask type I64_Array.

I64x2

type I64x2 is private;

Public lane, array, vector, or mask type I64x2.

I8

subtype I8 is Interfaces.Integer_8;

Public lane, array, vector, or mask type I8.

I8_Array

type I8_Array is array (Natural range <>) of aliased I8;

Public lane, array, vector, or mask type I8_Array.

I8x16

type I8x16 is private;

Public lane, array, vector, or mask type I8x16.

Interleave_High

function Interleave_High (Left, Right : F32x4) return F32x4

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 4s lanes. The x86-64 backend uses the SSE2 unpckhps instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : F64x2) return F64x2

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 2d lanes. The x86-64 backend uses the SSE2 unpckhpd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I16x8) return I16x8

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 8h lanes. The x86-64 backend uses the SSE2 punpckhwd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I32x4) return I32x4

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 4s lanes. The x86-64 backend uses the SSE2 punpckhdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I64x2) return I64x2

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpckhqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : I8x16) return I8x16

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 16b lanes. The x86-64 backend uses the SSE2 punpckhbw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U16x8) return U16x8

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 8h lanes. The x86-64 backend uses the SSE2 punpckhwd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U32x4) return U32x4

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 4s lanes. The x86-64 backend uses the SSE2 punpckhdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U64x2) return U64x2

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpckhqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_High

function Interleave_High (Left, Right : U8x16) return U8x16

Alternate lanes from the high half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip2 instruction over 16b lanes. The x86-64 backend uses the SSE2 punpckhbw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : F32x4) return F32x4

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 4s lanes. The x86-64 backend uses the SSE2 unpcklps instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : F64x2) return F64x2

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 2d lanes. The x86-64 backend uses the SSE2 unpcklpd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I16x8) return I16x8

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 8h lanes. The x86-64 backend uses the SSE2 punpcklwd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I32x4) return I32x4

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 4s lanes. The x86-64 backend uses the SSE2 punpckldq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I64x2) return I64x2

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : I8x16) return I8x16

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 16b lanes. The x86-64 backend uses the SSE2 punpcklbw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U16x8) return U16x8

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 8h lanes. The x86-64 backend uses the SSE2 punpcklwd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U32x4) return U32x4

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 4s lanes. The x86-64 backend uses the SSE2 punpckldq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U64x2) return U64x2

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 2d lanes. The x86-64 backend uses the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Interleave_Low

function Interleave_Low (Left, Right : U8x16) return U8x16

Alternate lanes from the low half of both inputs, starting with the left input. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON zip1 instruction over 16b lanes. The x86-64 backend uses the SSE2 punpcklbw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : Byte_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : F32_Array; Start : Natural) return Boolean

Report whether the selected first element has a 16-byte-aligned address. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends first check that Start is in the array range. For a valid Start, they test the selected element address modulo 16 directly with fixed-width Ada code. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : F64_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I16_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I32_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I64_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : I8_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : U16_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : U32_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Is_Aligned_16

function Is_Aligned_16 (Data : U64_Array; Start : Natural) return Boolean

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Lane_Count_16x8

subtype Lane_Count_16x8 is Natural range 0 .. 8;

Public lane, array, vector, or mask type Lane_Count_16x8.

Lane_Count_32x4

subtype Lane_Count_32x4 is Natural range 0 .. 4;

Public lane, array, vector, or mask type Lane_Count_32x4.

Lane_Count_64x2

subtype Lane_Count_64x2 is Natural range 0 .. 2;

Public lane, array, vector, or mask type Lane_Count_64x2.

Lane_Count_8x16

subtype Lane_Count_8x16 is Natural range 0 .. 16;

Public lane, array, vector, or mask type Lane_Count_8x16.

Lane_Index_16x8

subtype Lane_Index_16x8 is Natural range 0 .. 7;

Public lane, array, vector, or mask type Lane_Index_16x8.

Lane_Index_32x4

subtype Lane_Index_32x4 is Natural range 0 .. 3;

Public lane, array, vector, or mask type Lane_Index_32x4.

Lane_Index_64x2

subtype Lane_Index_64x2 is Natural range 0 .. 1;

Public lane, array, vector, or mask type Lane_Index_64x2.

Lane_Index_8x16

subtype Lane_Index_8x16 is Natural range 0 .. 15;

Public lane, array, vector, or mask type Lane_Index_8x16.

Lane_Map_16x8

type Lane_Map_16x8 is private;

A private, reusable result-lane to source-lane map.

Lane_Map_32x4

type Lane_Map_32x4 is private;

A private, reusable result-lane to source-lane map.

Lane_Map_64x2

type Lane_Map_64x2 is private;

A private, reusable result-lane to source-lane map.

Lane_Map_8x16

type Lane_Map_8x16 is private;

A reusable, validated mapping from result lanes to source lanes.

Lane_Selectors_16x8

type Lane_Selectors_16x8 is array (Lane_Index_16x8) of Lane_Index_16x8;

One valid source-lane selector for each result lane.

Lane_Selectors_32x4

type Lane_Selectors_32x4 is array (Lane_Index_32x4) of Lane_Index_32x4;

One valid source-lane selector for each result lane.

Lane_Selectors_64x2

type Lane_Selectors_64x2 is array (Lane_Index_64x2) of Lane_Index_64x2;

One valid source-lane selector for each result lane.

Lane_Selectors_8x16

type Lane_Selectors_8x16 is
  array (Lane_Index_8x16) of Lane_Index_8x16;

One source-lane selector for each result lane.

Lane_Values_8x16

type Lane_Values_8x16 is array (Lane_Index_8x16) of U8;

Public lane, array, vector, or mask type Lane_Values_8x16.

Lane_Values_F32x4

type Lane_Values_F32x4 is array (Lane_Index_32x4) of F32;

Public lane, array, vector, or mask type Lane_Values_F32x4.

Lane_Values_F64x2

type Lane_Values_F64x2 is array (Lane_Index_64x2) of F64;

Public lane, array, vector, or mask type Lane_Values_F64x2.

Lane_Values_I16x8

type Lane_Values_I16x8 is array (Lane_Index_16x8) of I16;

Public lane, array, vector, or mask type Lane_Values_I16x8.

Lane_Values_I32x4

type Lane_Values_I32x4 is array (Lane_Index_32x4) of I32;

Public lane, array, vector, or mask type Lane_Values_I32x4.

Lane_Values_I64x2

type Lane_Values_I64x2 is array (Lane_Index_64x2) of I64;

Public lane, array, vector, or mask type Lane_Values_I64x2.

Lane_Values_I8x16

type Lane_Values_I8x16 is array (Lane_Index_8x16) of I8;

Public lane, array, vector, or mask type Lane_Values_I8x16.

Lane_Values_U16x8

type Lane_Values_U16x8 is array (Lane_Index_16x8) of U16;

Public lane, array, vector, or mask type Lane_Values_U16x8.

Lane_Values_U32x4

type Lane_Values_U32x4 is array (Lane_Index_32x4) of U32;

Public lane, array, vector, or mask type Lane_Values_U32x4.

Lane_Values_U64x2

type Lane_Values_U64x2 is array (Lane_Index_64x2) of U64;

Public lane, array, vector, or mask type Lane_Values_U64x2.

Last_True

function Last_True (Mask : Mask_16x8) return Lane_Count_16x8

Return the last true lane, or the lane-count value when no lane is true. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated leading-zero-count sequence to find the last set compact-mask bit. The x86-64 backend uses a dedicated bit-scan-reverse sequence to find the last set compact-mask bit. Both return the lane-count value for a zero mask. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_32x4) return Lane_Count_32x4

Parameters

Mask: The input mask.

Return value

The operation result.

Last_True

function Last_True (Mask : Mask_64x2) return Lane_Count_64x2

Parameters

Mask: The input mask.

Return value

The operation result. END GENERATED 128-BIT FAMILIES

Last_True

function Last_True (Mask : Mask_8x16) return Lane_Count_8x16

Parameters

Mask: The input mask.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmge with reversed operands comparison over 4s lanes for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 cmpleps comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmge with reversed operands comparison over 2d lanes for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 cmplepd comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 8h lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison merged with pcmpeqw equality using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 4s lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison merged with pcmpeqd equality using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 2d lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmge comparison over 16b lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison merged with pcmpeqb equality using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 8h lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison with an unsigned sign-bit bias merged with pcmpeqw equality using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 4s lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison with an unsigned sign-bit bias merged with pcmpeqd equality using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 2d lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Equal

function Less_Equal (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhs comparison over 16b lanes with reversed operands for the less-than-or-equal predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison with an unsigned sign-bit bias merged with pcmpeqb equality using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : F32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmgt with reversed operands comparison over 4s lanes for the less-than predicate. The x86-64 backend uses the SSE2 cmpltps comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : F64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fcmgt with reversed operands comparison over 2d lanes for the less-than predicate. The x86-64 backend uses the SSE2 cmpltpd comparison for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 8h lanes with reversed operands for the less-than predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 4s lanes with reversed operands for the less-than predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 2d lanes with reversed operands for the less-than predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : I8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmgt comparison over 16b lanes with reversed operands for the less-than predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U16x8) return Mask_16x8

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 8h lanes with reversed operands for the less-than predicate. The x86-64 backend uses the SSE2 pcmpgtw comparison with an unsigned sign-bit bias using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U32x4) return Mask_32x4

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 4s lanes with reversed operands for the less-than predicate. The x86-64 backend uses the SSE2 pcmpgtd comparison with an unsigned sign-bit bias using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U64x2) return Mask_64x2

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 2d lanes with reversed operands for the less-than predicate. The x86-64 backend uses an SSE2 equality-gated two-dword lexicographic comparison using pcmpgtd with an unsigned sign-bit bias for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Less_Than

function Less_Than (Left, Right : U8x16) return Mask_8x16

Compare corresponding lanes with the lane type's ordering. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON cmhi comparison over 16b lanes with reversed operands for the less-than predicate. The x86-64 backend uses the SSE2 pcmpgtb comparison with an unsigned sign-bit bias using reversed operands for the same predicate. Both compact the lane results into the public mask. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Load

function Load (Data : Byte_Array; Start : Natural) return U8x16

Load one complete vector without an alignment requirement. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend delegates to Load_Unaligned, whose isolated NEON leaf loads the array into a vector register with ldr q. The x86-64 backend delegates to Load_Unaligned, which loads the array into a vector register with movdqu. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : F32_Array; Start : Natural) return F32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : F64_Array; Start : Natural) return F64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I16_Array; Start : Natural) return I16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I32_Array; Start : Natural) return I32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I64_Array; Start : Natural) return I64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : I8_Array; Start : Natural) return I8x16

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : U16_Array; Start : Natural) return U16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : U32_Array; Start : Natural) return U32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load

function Load (Data : U64_Array; Start : Natural) return U64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : Byte_Array; Start : Natural) return U8x16

Load one complete vector from a 16-byte-aligned address. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the same ldr q transfer after checking the alignment precondition. The x86-64 backend loads the aligned array into a vector register with movdqa. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : F32_Array; Start : Natural) return F32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : F64_Array; Start : Natural) return F64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I16_Array; Start : Natural) return I16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I32_Array; Start : Natural) return I32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I64_Array; Start : Natural) return I64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : I8_Array; Start : Natural) return I8x16

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : U16_Array; Start : Natural) return U16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : U32_Array; Start : Natural) return U32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Aligned

function Load_Aligned (Data : U64_Array; Start : Natural) return U64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : Byte_Array; Start : Natural; Count : Lane_Count_8x16) return U8x16

Read exactly Count elements and set the remaining lanes to zero. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends read exactly Count elements and initialize every inactive result lane to positive zero with a direct fixed-width Ada loop. A zero count does not evaluate an element address. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : F32_Array; Start : Natural; Count : Lane_Count_32x4) return F32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : F64_Array; Start : Natural; Count : Lane_Count_64x2) return F64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I16_Array; Start : Natural; Count : Lane_Count_16x8) return I16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I32_Array; Start : Natural; Count : Lane_Count_32x4) return I32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I64_Array; Start : Natural; Count : Lane_Count_64x2) return I64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : I8_Array; Start : Natural; Count : Lane_Count_8x16) return I8x16

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U16_Array; Start : Natural; Count : Lane_Count_16x8) return U16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U32_Array; Start : Natural; Count : Lane_Count_32x4) return U32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Partial

function Load_Partial (Data : U64_Array; Start : Natural; Count : Lane_Count_64x2) return U64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : Byte_Array; Start : Natural) return U8x16

Load one complete vector from an address with any alignment. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses an isolated NEON leaf that loads the array into a vector register with ldr q. The x86-64 backend loads the array into a vector register with movdqu. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : F32_Array; Start : Natural) return F32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : F64_Array; Start : Natural) return F64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I16_Array; Start : Natural) return I16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I32_Array; Start : Natural) return I32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I64_Array; Start : Natural) return I64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : I8_Array; Start : Natural) return I8x16

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : U16_Array; Start : Natural) return U16x8

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : U32_Array; Start : Natural) return U32x4

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Load_Unaligned

function Load_Unaligned (Data : U64_Array; Start : Natural) return U64x2

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.

Return value

The operation result.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_16x8) return Lane_Map_16x8

Build a reusable lane map. For each result lane, the selector gives the source lane. Selectors can repeat source lanes. A default-initialized map selects source lane zero for every result lane. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable one-source lane map.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_32x4) return Lane_Map_32x4

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable one-source lane map.

Make_Lane_Map

function Make_Lane_Map (Selectors : Lane_Selectors_64x2) return Lane_Map_64x2

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable one-source lane map.

Make_Lane_Map

function Make_Lane_Map
  (Selectors : Lane_Selectors_8x16) return Lane_Map_8x16

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable one-source lane map.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_16x8) return Two_Source_Lane_Map_16x8

Build a reusable two-source lane map. For each result lane, the selector gives one lane of the left or right input. Selectors can repeat source lanes. A default-initialized map selects left lane zero for every result lane. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable two-source lane map.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_32x4) return Two_Source_Lane_Map_32x4

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable two-source lane map.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map (Selectors : Two_Source_Lane_Selectors_64x2) return Two_Source_Lane_Map_64x2

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable two-source lane map.

Make_Two_Source_Lane_Map

function Make_Two_Source_Lane_Map
  (Selectors : Two_Source_Lane_Selectors_8x16)
   return Two_Source_Lane_Map_8x16

Parameters

Selectors: One source-lane selector for each result lane.

Return value

A reusable two-source lane map.

Mask_16x8

type Mask_16x8 is private;

Public lane, array, vector, or mask type Mask_16x8.

Mask_32x4

type Mask_32x4 is private;

Public lane, array, vector, or mask type Mask_32x4.

Mask_64x2

type Mask_64x2 is private;

Public lane, array, vector, or mask type Mask_64x2.

Mask_8x16

type Mask_8x16 is private;

Public lane, array, vector, or mask type Mask_8x16.

Mask_And

function Mask_And (Left, Right : Mask_16x8) return Mask_16x8

Apply Boolean AND to corresponding mask lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_32x4) return Mask_32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_64x2) return Mask_64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_And

function Mask_And (Left, Right : Mask_8x16) return Mask_8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_16) return Mask_8x16

Construct lane truths from compact bits. Bit zero represents lane zero. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_8) return Mask_16x8

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_8) return Mask_32x4

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_From_Bit_Mask

function Mask_From_Bit_Mask (Bits : Interfaces.Unsigned_8) return Mask_64x2

Parameters

Bits: Compact lane bits. Bit zero represents lane zero.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_16x8) return Mask_16x8

Complement every mask lane truth. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_32x4) return Mask_32x4

Parameters

Value: The input value.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_64x2) return Mask_64x2

Parameters

Value: The input value.

Return value

The operation result.

Mask_Not

function Mask_Not (Value : Mask_8x16) return Mask_8x16

Parameters

Value: The input value.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_16x8) return Mask_16x8

Apply Boolean OR to corresponding mask lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_32x4) return Mask_32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_64x2) return Mask_64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Or

function Mask_Or (Left, Right : Mask_8x16) return Mask_8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_16x8) return Mask_16x8

Apply Boolean exclusive OR to corresponding mask lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_32x4) return Mask_32x4

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_64x2) return Mask_64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Mask_Xor

function Mask_Xor (Left, Right : Mask_8x16) return Mask_8x16

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I16x8) return I16x8

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON smax instruction over 8h lanes. The x86-64 backend uses one SSE2 pmaxsw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I32x4) return I32x4

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON smax instruction over 4s lanes. The x86-64 backend uses an SSE2 pcmpgtd comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I64x2) return I64x2

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON cmgt comparison followed by bif selection over 2d lanes. The x86-64 backend uses an SSE2 equality-gated two-dword signed lexicographic comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : I8x16) return I8x16

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON smax instruction over 16b lanes. The x86-64 backend uses an SSE2 pcmpgtb comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U16x8) return U16x8

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON umax instruction over 8h lanes. The x86-64 backend uses an SSE2 pcmpgtw comparison with unsigned sign-bit bias followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U32x4) return U32x4

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON umax instruction over 4s lanes. The x86-64 backend uses an SSE2 pcmpgtd comparison with unsigned sign-bit bias followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U64x2) return U64x2

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON cmhi comparison followed by bif selection over 2d lanes. The x86-64 backend uses an SSE2 equality-gated two-dword unsigned lexicographic comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max

function Max (Left, Right : U8x16) return U8x16

Return the larger integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON umax instruction over 16b lanes. The x86-64 backend uses one SSE2 pmaxub instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max_Number

function Max_Number (Left, Right : F32x4) return F32x4

Return the floating number maximum with the documented NaN and signed-zero rules. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fmaxnm instruction over 4s lanes. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that preserves the documented NaN and signed-zero rules. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Max_Number

function Max_Number (Left, Right : F64x2) return F64x2

Return the floating number maximum with the documented NaN and signed-zero rules. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fmaxnm instruction over 2d lanes. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that preserves the documented NaN and signed-zero rules. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I16x8) return I16x8

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON smin instruction over 8h lanes. The x86-64 backend uses one SSE2 pminsw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I32x4) return I32x4

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON smin instruction over 4s lanes. The x86-64 backend uses an SSE2 pcmpgtd comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I64x2) return I64x2

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON cmgt comparison followed by bit selection over 2d lanes. The x86-64 backend uses an SSE2 equality-gated two-dword signed lexicographic comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : I8x16) return I8x16

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON smin instruction over 16b lanes. The x86-64 backend uses an SSE2 pcmpgtb comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U16x8) return U16x8

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON umin instruction over 8h lanes. The x86-64 backend uses an SSE2 pcmpgtw comparison with unsigned sign-bit bias followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U32x4) return U32x4

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON umin instruction over 4s lanes. The x86-64 backend uses an SSE2 pcmpgtd comparison with unsigned sign-bit bias followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U64x2) return U64x2

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON cmhi comparison followed by bit selection over 2d lanes. The x86-64 backend uses an SSE2 equality-gated two-dword unsigned lexicographic comparison followed by compact-mask expansion and pand, pandn, and por selection. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min

function Min (Left, Right : U8x16) return U8x16

Return the smaller integer in each lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON umin instruction over 16b lanes. The x86-64 backend uses one SSE2 pminub instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min_Number

function Min_Number (Left, Right : F32x4) return F32x4

Return the floating number minimum with the documented NaN and signed-zero rules. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fminnm instruction over 4s lanes. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that preserves the documented NaN and signed-zero rules. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Min_Number

function Min_Number (Left, Right : F64x2) return F64x2

Return the floating number minimum with the documented NaN and signed-zero rules. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fminnm instruction over 2d lanes. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that preserves the documented NaN and signed-zero rules. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply

function Multiply (Left, Right : F32x4) return F32x4

Multiply corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fmul instruction over 4s lanes. The x86-64 backend uses the SSE2 mulps instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply

function Multiply (Left, Right : F64x2) return F64x2

Multiply corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fmul instruction over 2d lanes. The x86-64 backend uses the SSE2 mulpd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I16x8) return I16x8

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON mul instruction over 8h lanes. The x86-64 backend uses the SSE2 pmullw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I32x4) return I32x4

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON mul instruction over 4s lanes. The x86-64 backend uses an SSE2 sequence that uses two pmuludq instructions and repacks the dword products. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I64x2) return I64x2

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON 32-bit partial-product sequence. The x86-64 backend uses an SSE2 three-pmuludq partial-product sequence. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : I8x16) return I8x16

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON mul instruction over 16b lanes. The x86-64 backend uses an SSE2 sequence that widens bytes, uses two pmullw instructions, and packs the low product bytes. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U32x4) return U32x4

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON mul instruction over 4s lanes. The x86-64 backend uses an SSE2 sequence that uses two pmuludq instructions and repacks the dword products. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U64x2) return U64x2

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a NEON 32-bit partial-product sequence. The x86-64 backend uses an SSE2 three-pmuludq partial-product sequence. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Multiply_Wrap

function Multiply_Wrap (Left, Right : U8x16) return U8x16

Multiply corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON mul instruction over 16b lanes. The x86-64 backend uses an SSE2 sequence that widens bytes, uses two pmullw instructions, and packs the low product bytes. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Narrow_Round

function Narrow_Round (Low, High : F64x2) return F32x4

With the default round-to-nearest, ties-to-even and gradual-underflow environment, round Low into result lanes zero and one and High into lanes two and three. Signed zero and infinity are preserved. Overflow after rounding produces infinity. Gradual underflow can produce a subnormal, and a sufficiently small magnitude rounds to signed zero. A NaN remains a NaN, but its payload and signaling state are unspecified. The operation does not change the rounding mode or exception-control settings. It can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that converts the lanes with fcvtn and fcvtn2. The x86-64 backend uses a dedicated SSE2 sequence that converts with cvtpd2ps and merges the result lanes. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I16x8) return I8x16

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sqxtn.8b and sqxtn2.16b instructions. The x86-64 backend uses the SSE2 packsswb instruction. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I16x8) return U8x16

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sqxtun.8b and sqxtun2.16b instructions. The x86-64 backend uses the SSE2 packuswb instruction. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I32x4) return I16x8

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sqxtn.4h and sqxtn2.8h instructions. The x86-64 backend uses the SSE2 packssdw instruction. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I32x4) return U16x8

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sqxtun.4h and sqxtun2.8h instructions. The x86-64 backend uses an SSE2 pcmpgtd, pandn, pshufd, and punpcklqdq clamp-and-pack sequence. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I64x2) return I32x4

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sqxtn.2s and sqxtn2.4s instructions. The x86-64 backend uses an SSE2 psrad, pcmpeqd, pandn, pshufd, and punpcklqdq clamp-and-pack sequence. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : I64x2) return U32x4

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sqxtun.2s and sqxtun2.4s instructions. The x86-64 backend uses an SSE2 psrad, pcmpeqd, pandn, pshufd, and punpcklqdq clamp-and-pack sequence. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U16x8) return U8x16

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uqxtn.8b and uqxtn2.16b instructions. The x86-64 backend uses an SSE2 psrlw, pcmpeqw, pandn, and packuswb clamp-and-pack sequence. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U32x4) return U16x8

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uqxtn.4h and uqxtn2.8h instructions. The x86-64 backend uses an SSE2 psrld, pcmpeqd, pandn, and punpcklqdq clamp-and-pack sequence. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Saturate

function Narrow_Saturate (Low, High : U64x2) return U32x4

Clamp each source lane to the result range and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uqxtn.2s and uqxtn2.4s instructions. The x86-64 backend uses an SSE2 psrlq, pcmpeqd, pandn, pshufd, and punpcklqdq clamp-and-pack sequence. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I16x8) return I8x16

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON xtn.8b and xtn2.16b instructions. The x86-64 backend uses an SSE2 packuswb sequence that retains each lane's low byte. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I32x4) return I16x8

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON xtn.4h and xtn2.8h instructions. The x86-64 backend uses an SSE2 pshuflw, pshufhw, pshufd, and punpcklqdq sequence that retains each lane's low word. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : I64x2) return I32x4

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON xtn.2s and xtn2.4s instructions. The x86-64 backend uses an SSE2 pshufd and punpcklqdq sequence that retains each lane's low doubleword. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U16x8) return U8x16

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U32x4) return U16x8

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON xtn.4h and xtn2.8h instructions. The x86-64 backend uses an SSE2 pshuflw, pshufhw, pshufd, and punpcklqdq sequence that retains each lane's low word. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

Narrow_Truncate

function Narrow_Truncate (Low, High : U64x2) return U32x4

Keep the low bits of each source lane and combine both source vectors. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON xtn.2s and xtn2.4s instructions. The x86-64 backend uses an SSE2 pshufd and punpcklqdq sequence that retains each lane's low doubleword. A scalar build uses the portable scalar implementation.

Parameters

Low: The source for the low result half.
High: The source for the high result half.

Return value

The operation result.

None_True

function None_True (Mask : Mask_16x8) return Boolean

Return true when every mask lane is false. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

None_True

function None_True (Mask : Mask_32x4) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

None_True

function None_True (Mask : Mask_64x2) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

None_True

function None_True (Mask : Mask_8x16) return Boolean

Parameters

Mask: The input mask.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : F32x4; Map : Two_Source_Lane_Map_32x4) return F32x4

Select each result lane from the left or right vector through a reusable two-source lane map. Moved lanes keep their complete bit encoding. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON tbl sequence that selects complete lane byte groups through the reusable map. The x86-64 backend uses a dedicated SSE2 sequence that compares every byte selector with each valid source position, broadcasts matching source bytes, and merges them into the result. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : F32x4; Map : Lane_Map_32x4) return F32x4

Select each result lane through a reusable lane map. Moved lanes keep their complete bit encoding. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON tbl sequence that selects complete lane byte groups through the reusable map. The x86-64 backend uses a dedicated SSE2 sequence that compares every byte selector with each valid source position, broadcasts matching source bytes, and merges them into the result. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : F64x2; Map : Two_Source_Lane_Map_64x2) return F64x2

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : F64x2; Map : Lane_Map_64x2) return F64x2

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I16x8; Map : Two_Source_Lane_Map_16x8) return I16x8

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I16x8; Map : Lane_Map_16x8) return I16x8

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I32x4; Map : Two_Source_Lane_Map_32x4) return I32x4

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I32x4; Map : Lane_Map_32x4) return I32x4

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I64x2; Map : Two_Source_Lane_Map_64x2) return I64x2

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I64x2; Map : Lane_Map_64x2) return I64x2

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : I8x16; Map : Two_Source_Lane_Map_8x16) return I8x16

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : I8x16; Map : Lane_Map_8x16) return I8x16

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U16x8; Map : Lane_Map_16x8) return U16x8

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U16x8; Map : Two_Source_Lane_Map_16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U32x4; Map : Lane_Map_32x4) return U32x4

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U32x4; Map : Two_Source_Lane_Map_32x4) return U32x4

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U64x2; Map : Lane_Map_64x2) return U64x2

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U64x2; Map : Two_Source_Lane_Map_64x2) return U64x2

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Value : U8x16; Map : Lane_Map_8x16) return U8x16

Parameters

Value: The input value.
Map: The reusable lane map.

Return value

The operation result.

Permute_Lanes

function Permute_Lanes (Left, Right : U8x16; Map : Two_Source_Lane_Map_8x16) return U8x16

Parameters

Left: The left input.
Right: The right input.
Map: The reusable lane map.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_16x8) return Lane_Count_16x8

Return the number of true mask lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend counts set bits with a dedicated NEON byte-count and horizontal-add sequence. The x86-64 backend uses a dedicated fixed-width arithmetic bit-count sequence that does not require POPCNT. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_32x4) return Lane_Count_32x4

Parameters

Mask: The input mask.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_64x2) return Lane_Count_64x2

Parameters

Mask: The input mask.

Return value

The operation result.

Population_Count

function Population_Count (Mask : Mask_8x16) return Lane_Count_8x16

Parameters

Mask: The input mask.

Return value

The operation result.

Reduce_Add

function Reduce_Add (Value : F32x4) return F32

Add all floating lanes in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that starts from positive zero and adds one binary32 lane at a time in ascending order. The x86-64 backend uses a dedicated SSE2 sequence that starts from positive zero and adds one binary32 lane at a time in ascending order. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add

function Reduce_Add (Value : F64x2) return F64

Add all floating lanes in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that starts from positive zero and adds one binary64 lane at a time in ascending order. The x86-64 backend uses a dedicated SSE2 sequence that starts from positive zero and adds one binary64 lane at a time in ascending order. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I16x8) return I16

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON addv instruction over eight 16-bit lanes. The x86-64 backend uses the SSE2 paddw instruction in a three-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I32x4) return I32

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON addv instruction over four 32-bit lanes. The x86-64 backend uses the SSE2 paddd instruction in a two-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I64x2) return I64

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON addp instruction over two 64-bit lanes. The x86-64 backend uses the SSE2 paddq instruction in a one-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : I8x16) return I8

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON addv instruction over 16 byte lanes. The x86-64 backend uses the SSE2 paddb instruction in a four-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U16x8) return U16

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U32x4) return U32

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON addv instruction over four 32-bit lanes. The x86-64 backend uses the SSE2 paddd instruction in a two-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U64x2) return U64

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON addp instruction over two 64-bit lanes. The x86-64 backend uses the SSE2 paddq instruction in a one-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Add_Wrap

function Reduce_Add_Wrap (Value : U8x16) return U8

Add all integer lanes modulo the lane width in ascending lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uaddlv instruction to form a widening sum and retains its low eight bits. The x86-64 backend uses the SSE2 paddb instruction in a four-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I16x8) return I16

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON smaxv instruction over eight 16-bit lanes. The x86-64 backend uses the SSE2 pmaxsw instruction in a three-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I32x4) return I32

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON smaxv instruction over four 32-bit lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtd comparison-and-selection maximum reduction in a 2-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I64x2) return I64

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that broadcasts the high lane, compares with cmgt, and selects the maximum with bif. The x86-64 backend uses a dedicated SSE2 equality-gated two-dword lexicographic comparison that selects the maximum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : I8x16) return I8

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON smaxv instruction over 16 byte lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtb comparison-and-selection maximum reduction in a 4-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U16x8) return U16

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON umaxv instruction over eight 16-bit lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtw with a sign-bit bias comparison-and-selection maximum reduction in a 3-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U32x4) return U32

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON umaxv instruction over four 32-bit lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtd with a sign-bit bias comparison-and-selection maximum reduction in a 2-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U64x2) return U64

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that broadcasts the high lane, compares with cmhi, and selects the maximum with bif. The x86-64 backend uses a dedicated SSE2 equality-gated two-dword lexicographic comparison with a sign-bit bias that selects the maximum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max

function Reduce_Max (Value : U8x16) return U8

Return the largest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON umaxv instruction over 16 byte lanes. The x86-64 backend uses the SSE2 pmaxub instruction in a four-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max_Number

function Reduce_Max_Number (Value : F32x4) return F32

Use lane zero as the initial result. Apply Max_Number to each remaining lane in ascending order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON number-maximum sequence. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that folds lanes in ascending order. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Max_Number

function Reduce_Max_Number (Value : F64x2) return F64

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I16x8) return I16

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sminv instruction over eight 16-bit lanes. The x86-64 backend uses the SSE2 pminsw instruction in a three-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I32x4) return I32

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sminv instruction over four 32-bit lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtd comparison-and-selection minimum reduction in a 2-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I64x2) return I64

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that broadcasts the high lane, compares with cmgt, and selects the minimum with bit. The x86-64 backend uses a dedicated SSE2 equality-gated two-dword lexicographic comparison that selects the minimum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : I8x16) return I8

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sminv instruction over 16 byte lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtb comparison-and-selection minimum reduction in a 4-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U16x8) return U16

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uminv instruction over eight 16-bit lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtw with a sign-bit bias comparison-and-selection minimum reduction in a 3-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U32x4) return U32

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uminv instruction over four 32-bit lanes. The x86-64 backend uses a dedicated SSE2 pcmpgtd with a sign-bit bias comparison-and-selection minimum reduction in a 2-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U64x2) return U64

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that broadcasts the high lane, compares with cmhi, and selects the minimum with bit. The x86-64 backend uses a dedicated SSE2 equality-gated two-dword lexicographic comparison with a sign-bit bias that selects the minimum. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min

function Reduce_Min (Value : U8x16) return U8

Return the smallest integer lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON uminv instruction over 16 byte lanes. The x86-64 backend uses the SSE2 pminub instruction in a four-stage fixed-shuffle tree. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min_Number

function Reduce_Min_Number (Value : F32x4) return F32

Use lane zero as the initial result. Apply Min_Number to each remaining lane in ascending order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON number-minimum sequence. The x86-64 backend uses a dedicated integer-only SSE2 classification and bit-selection sequence that folds lanes in ascending order. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reduce_Min_Number

function Reduce_Min_Number (Value : F64x2) return F64

Parameters

Value: The input value.

Return value

The operation result.

Replace

function Replace (Value : F32x4; Lane : Lane_Index_32x4; With_Value : F32) return F32x4

Return a copy with one logical lane replaced. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends copy private vector storage and write the selected position directly with fixed-width Ada code. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : F64x2; Lane : Lane_Index_64x2; With_Value : F64) return F64x2

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I16x8; Lane : Lane_Index_16x8; With_Value : I16) return I16x8

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I32x4; Lane : Lane_Index_32x4; With_Value : I32) return I32x4

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I64x2; Lane : Lane_Index_64x2; With_Value : I64) return I64x2

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : I8x16; Lane : Lane_Index_8x16; With_Value : I8) return I8x16

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U16x8; Lane : Lane_Index_16x8; With_Value : U16) return U16x8

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U32x4; Lane : Lane_Index_32x4; With_Value : U32) return U32x4

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U64x2; Lane : Lane_Index_64x2; With_Value : U64) return U64x2

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Replace

function Replace (Value : U8x16; Lane : Lane_Index_8x16; With_Value : U8) return U8x16

Parameters

Value: The input value.
Lane: The logical lane index.
With_Value: The replacement lane value.

Return value

The operation result.

Reverse_Bytes

function Reverse_Bytes (Value : U8x16) return U8x16

Reverse logical byte-lane order. This is the compatibility name for Reverse_Lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON implementation. The x86-64 backend uses a dedicated SSE2 implementation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : F32x4) return F32x4

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses NEON rev64 over 4s lanes followed by ext with an eight-byte offset. The x86-64 backend uses SSE2 pshufd with control 0x1B. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : F64x2) return F64x2

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ext instruction with an eight-byte offset. The x86-64 backend uses SSE2 pshufd with control 0x4E. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I16x8) return I16x8

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses NEON rev64 over 8h lanes followed by ext with an eight-byte offset. The x86-64 backend uses SSE2 pshuflw, pshufhw, and pshufd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I32x4) return I32x4

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I64x2) return I64x2

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ext instruction with an eight-byte offset. The x86-64 backend uses SSE2 pshufd with control 0x4E. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : I8x16) return I8x16

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses NEON rev64 over 16b lanes followed by ext with an eight-byte offset. The x86-64 backend uses SSE2 byte shifts and OR followed by pshuflw, pshufhw, and pshufd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U16x8) return U16x8

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses NEON rev64 over 8h lanes followed by ext with an eight-byte offset. The x86-64 backend uses SSE2 pshuflw, pshufhw, and pshufd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U32x4) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U64x2) return U64x2

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ext instruction with an eight-byte offset. The x86-64 backend uses SSE2 pshufd with control 0x4E. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Reverse_Lanes

function Reverse_Lanes (Value : U8x16) return U8x16

Reverse logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses NEON rev64 over 16b lanes followed by ext with an eight-byte offset. The x86-64 backend uses SSE2 byte shifts and OR followed by pshuflw, pshufhw, and pshufd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_16x8) return Two_Source_Lane_Selector_16x8

Construct a selector for one lane of the left input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested left-input lane.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_32x4) return Two_Source_Lane_Selector_32x4

Construct a selector for one lane of the left input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested left-input lane.

Select_Left_Lane

function Select_Left_Lane (Lane : Lane_Index_64x2) return Two_Source_Lane_Selector_64x2

Construct a selector for one lane of the left input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested left-input lane.

Select_Left_Lane

function Select_Left_Lane
  (Lane : Lane_Index_8x16) return Two_Source_Lane_Selector_8x16

Construct a selector for one lane of the left input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested left-input lane.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_16x8) return Two_Source_Lane_Selector_16x8

Construct a selector for one lane of the right input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested right-input lane.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_32x4) return Two_Source_Lane_Selector_32x4

Construct a selector for one lane of the right input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested right-input lane.

Select_Right_Lane

function Select_Right_Lane (Lane : Lane_Index_64x2) return Two_Source_Lane_Selector_64x2

Construct a selector for one lane of the right input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested right-input lane.

Select_Right_Lane

function Select_Right_Lane
  (Lane : Lane_Index_8x16) return Two_Source_Lane_Selector_8x16

Construct a selector for one lane of the right input. Cross-platform support: this fixed-width Ada operation is available on every supported GNAT target and has no separate Backends.Native overload.

Parameters

Lane: The logical lane index.

Return value

A selector for the requested right-input lane.

Select_Value

function Select_Value (Mask : Mask_16x8; If_True, If_False : I16x8) return I16x8

Select the true input in true mask lanes and the false input in other lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON compact-mask expansion and bit-selection sequence. The x86-64 backend uses a dedicated SSE2 compact-mask expansion and bit-selection sequence. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_16x8; If_True, If_False : U16x8) return U16x8

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x4; If_True, If_False : F32x4) return F32x4

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x4; If_True, If_False : I32x4) return I32x4

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_32x4; If_True, If_False : U32x4) return U32x4

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x2; If_True, If_False : F64x2) return F64x2

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x2; If_True, If_False : I64x2) return I64x2

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_64x2; If_True, If_False : U64x2) return U64x2

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_8x16; If_True, If_False : I8x16) return I8x16

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Select_Value

function Select_Value (Mask : Mask_8x16; If_True, If_False : U8x16) return U8x16

Parameters

Mask: The input mask.
If_True: The value selected in true mask lanes.
If_False: The value selected in false mask lanes.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I16x8; Count : Natural) return I16x8

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 16-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that shifts the 16-bit lanes with psllw. When Count exceeds 16, both backends clamp it to 16. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I32x4; Count : Natural) return I32x4

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 32-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that shifts the 32-bit lanes with pslld. When Count exceeds 32, both backends clamp it to 32. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I64x2; Count : Natural) return I64x2

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 64-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that shifts the 64-bit lanes with psllq. When Count exceeds 64, both backends clamp it to 64. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : I8x16; Count : Natural) return I8x16

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 8-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that widens the bytes, shifts the 16-bit lanes left, and packs the result bytes. When Count exceeds 8, both backends clamp it to 8. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U16x8; Count : Natural) return U16x8

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U32x4; Count : Natural) return U32x4

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 32-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that shifts the 32-bit lanes with pslld. When Count exceeds 32, both backends clamp it to 32. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U64x2; Count : Natural) return U64x2

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 64-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that shifts the 64-bit lanes with psllq. When Count exceeds 64, both backends clamp it to 64. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Left_Logical

function Shift_Left_Logical (Value : U8x16; Count : Natural) return U8x16

Shift each lane left. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 8-bit lanes with the NEON ushl instruction and a positive count. The x86-64 backend uses an SSE2 sequence that widens the bytes, shifts the 16-bit lanes left, and packs the result bytes. When Count exceeds 8, both backends clamp it to 8. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I16x8; Count : Natural) return I16x8

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the signed 16-bit lanes with the NEON sshl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the signed 16-bit lanes with psraw. When Count exceeds 16, both backends clamp it to 16. The clamped count produces the defined full sign fill without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I32x4; Count : Natural) return I32x4

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the signed 32-bit lanes with the NEON sshl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the signed 32-bit lanes with psrad. When Count exceeds 32, both backends clamp it to 32. The clamped count produces the defined full sign fill without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I64x2; Count : Natural) return I64x2

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the signed 64-bit lanes with the NEON sshl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that derives each lane's sign mask, applies a logical right shift to each 64-bit lane and its sign mask, and merges the sign fill. When Count exceeds 64, both backends clamp it to 64. The clamped count produces the defined full sign fill without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Arithmetic

function Shift_Right_Arithmetic (Value : I8x16; Count : Natural) return I8x16

Shift each signed lane right with sign fill. Use full sign fill when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the signed 8-bit lanes with the NEON sshl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that widens the signed bytes, shifts the 16-bit lanes with psraw, and packs the result bytes. When Count exceeds 8, both backends clamp it to 8. The clamped count produces the defined full sign fill without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I16x8; Count : Natural) return I16x8

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 16-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the 16-bit lanes with psrlw. When Count exceeds 16, both backends clamp it to 16. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I32x4; Count : Natural) return I32x4

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 32-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the 32-bit lanes with psrld. When Count exceeds 32, both backends clamp it to 32. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I64x2; Count : Natural) return I64x2

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 64-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the 64-bit lanes with psrlq. When Count exceeds 64, both backends clamp it to 64. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : I8x16; Count : Natural) return I8x16

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 8-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that widens the bytes, shifts the 16-bit lanes right, and packs the result bytes. When Count exceeds 8, both backends clamp it to 8. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U16x8; Count : Natural) return U16x8

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U32x4; Count : Natural) return U32x4

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 32-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the 32-bit lanes with psrld. When Count exceeds 32, both backends clamp it to 32. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U64x2; Count : Natural) return U64x2

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 64-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that shifts the 64-bit lanes with psrlq. When Count exceeds 64, both backends clamp it to 64. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Shift_Right_Logical

function Shift_Right_Logical (Value : U8x16; Count : Natural) return U8x16

Shift each lane right with zero fill. Return zero lanes when the count reaches the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend shifts the 8-bit lanes with the NEON ushl instruction and a negative count. The x86-64 backend uses an SSE2 sequence that widens the bytes, shifts the 16-bit lanes right, and packs the result bytes. When Count exceeds 8, both backends clamp it to 8. The clamped count produces the defined all-zero result without calling the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of bit positions to shift.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : F32x4; Count : Natural) return F32x4

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 32-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 4, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation. Vacated floating lanes contain positive zero.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : F64x2; Count : Natural) return F64x2

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 64-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 2, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation. Vacated floating lanes contain positive zero.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I16x8; Count : Natural) return I16x8

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 16-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 8, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I32x4; Count : Natural) return I32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I64x2; Count : Natural) return I64x2

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 64-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 2, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : I8x16; Count : Natural) return I8x16

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 8-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 16, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U16x8; Count : Natural) return U16x8

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 16-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 8, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U32x4; Count : Natural) return U32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U64x2; Count : Natural) return U64x2

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 64-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 2, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_High

function Slide_Lanes_Toward_High (Value : U8x16; Count : Natural) return U8x16

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward higher lane indexes and fill vacated low-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 8-bit lanes toward higher indexes and inserts zero bytes. The x86-64 backend uses SSE2 pslldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 16, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : F32x4; Count : Natural) return F32x4

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 32-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 4, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation. Vacated floating lanes contain positive zero.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : F64x2; Count : Natural) return F64x2

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 64-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 2, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation. Vacated floating lanes contain positive zero.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I16x8; Count : Natural) return I16x8

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 16-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 8, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I32x4; Count : Natural) return I32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I64x2; Count : Natural) return I64x2

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 64-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 2, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : I8x16; Count : Natural) return I8x16

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 8-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 16, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U16x8; Count : Natural) return U16x8

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 16-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 8, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U32x4; Count : Natural) return U32x4

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U64x2; Count : Natural) return U64x2

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 64-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 2, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Slide_Lanes_Toward_Low

function Slide_Lanes_Toward_Low (Value : U8x16; Count : Natural) return U8x16

Count is in lanes. A zero count returns Value. Retained lanes keep their complete bit encoding. Move them toward lower lane indexes and fill vacated high-index lanes with zero. Return Zero when Count is equal to or greater than the lane count. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, for each in-range constant Count, the AArch64 backend uses NEON ext to move 8-bit lanes toward lower indexes and inserts zero bytes. The x86-64 backend uses SSE2 psrldq with the corresponding byte count. A zero count returns Value directly. When Count is equal to or greater than 16, each backend calls its own target Zero operation and does not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.
Count: The number of lane positions to move.

Return value

The operation result.

Splat

function Splat (Value : F32) return F32x4

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend broadcasts the input bits with the SSE2 pshufd instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : F64) return F64x2

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend broadcasts the input bits with the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I16) return I16x8

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend replicates the input bits through 32-bit width and broadcasts them with the SSE2 pshufd instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I32) return I32x4

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I64) return I64x2

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend broadcasts the input bits with the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : I8) return I8x16

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend replicates the input bits through 32-bit width and broadcasts them with the SSE2 pshufd instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U16) return U16x8

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend replicates the input bits through 32-bit width and broadcasts them with the SSE2 pshufd instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U32) return U32x4

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U64) return U64x2

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend broadcasts the input bits with the SSE2 punpcklqdq instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Splat

function Splat (Value : U8) return U8x16

Return a vector in which each lane has the same value. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend broadcasts the input bit encoding to every lane with the NEON dup instruction. The x86-64 backend replicates the input bits through 32-bit width and broadcasts them with the SSE2 pshufd instruction. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Store

procedure Store (Data : in out Byte_Array; Start : Natural; Value : U8x16)

Store one complete vector without an alignment requirement. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend delegates to Store_Unaligned, whose isolated NEON leaf stores a vector register to the array with str q. The x86-64 backend delegates to Store_Unaligned, which stores a vector register to the array with movdqu. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out F32_Array; Start : Natural; Value : F32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out F64_Array; Start : Natural; Value : F64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I16_Array; Start : Natural; Value : I16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I32_Array; Start : Natural; Value : I32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I64_Array; Start : Natural; Value : I64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out I8_Array; Start : Natural; Value : I8x16)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out U16_Array; Start : Natural; Value : U16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out U32_Array; Start : Natural; Value : U32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store

procedure Store (Data : in out U64_Array; Start : Natural; Value : U64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out Byte_Array; Start : Natural; Value : U8x16)

Store one complete vector to a 16-byte-aligned address. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the same str q transfer after checking the alignment precondition. The x86-64 backend stores a vector register to the aligned array with movdqa. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out F32_Array; Start : Natural; Value : F32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out F64_Array; Start : Natural; Value : F64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I16_Array; Start : Natural; Value : I16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I32_Array; Start : Natural; Value : I32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I64_Array; Start : Natural; Value : I64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out I8_Array; Start : Natural; Value : I8x16)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out U16_Array; Start : Natural; Value : U16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out U32_Array; Start : Natural; Value : U32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Aligned

procedure Store_Aligned (Data : in out U64_Array; Start : Natural; Value : U64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out Byte_Array; Start : Natural; Count : Lane_Count_8x16; Value : U8x16)

Write exactly Count elements and leave all other elements unchanged. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends write the first Count value lanes to exactly Count destination elements and leave every other array element unchanged with a direct fixed-width Ada loop. A zero count does not evaluate an element address. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out F32_Array; Start : Natural; Count : Lane_Count_32x4; Value : F32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out F64_Array; Start : Natural; Count : Lane_Count_64x2; Value : F64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I16_Array; Start : Natural; Count : Lane_Count_16x8; Value : I16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I32_Array; Start : Natural; Count : Lane_Count_32x4; Value : I32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I64_Array; Start : Natural; Count : Lane_Count_64x2; Value : I64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out I8_Array; Start : Natural; Count : Lane_Count_8x16; Value : I8x16)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out U16_Array; Start : Natural; Count : Lane_Count_16x8; Value : U16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out U32_Array; Start : Natural; Count : Lane_Count_32x4; Value : U32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Partial

procedure Store_Partial (Data : in out U64_Array; Start : Natural; Count : Lane_Count_64x2; Value : U64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Count: The number of valid elements.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out Byte_Array; Start : Natural; Value : U8x16)

Store one complete vector to an address with any alignment. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses an isolated NEON leaf that stores a vector register to the array with str q. The x86-64 backend stores a vector register to the array with movdqu. A scalar build uses the portable scalar implementation.

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out F32_Array; Start : Natural; Value : F32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out F64_Array; Start : Natural; Value : F64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I16_Array; Start : Natural; Value : I16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I32_Array; Start : Natural; Value : I32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I64_Array; Start : Natural; Value : I64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out I8_Array; Start : Natural; Value : I8x16)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out U16_Array; Start : Natural; Value : U16x8)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out U32_Array; Start : Natural; Value : U32x4)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Store_Unaligned

procedure Store_Unaligned (Data : in out U64_Array; Start : Natural; Value : U64x2)

Parameters

Data: The typed lane array.
Start: The Ada index of the first selected element.
Value: The input value.

Subtract

function Subtract (Left, Right : F32x4) return F32x4

Subtract corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fsub instruction over 4s lanes. The x86-64 backend uses the SSE2 subps instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract

function Subtract (Left, Right : F64x2) return F64x2

Subtract corresponding floating-point lanes. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON fsub instruction over 2d lanes. The x86-64 backend uses the SSE2 subpd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I16x8) return I16x8

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqsub instruction over 8h lanes. The x86-64 backend uses one SSE2 psubsw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I32x4) return I32x4

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqsub instruction over 4s lanes. The x86-64 backend uses an SSE2 sequence that derives a signed-overflow mask and selects the signed minimum or maximum. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I64x2) return I64x2

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqsub instruction over 2d lanes. The x86-64 backend uses an SSE2 sequence that derives a signed-overflow mask and selects the signed minimum or maximum. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : I8x16) return I8x16

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON sqsub instruction over 16b lanes. The x86-64 backend uses one SSE2 psubsb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U16x8) return U16x8

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqsub instruction over 8h lanes. The x86-64 backend uses one SSE2 psubusw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U32x4) return U32x4

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqsub instruction over 4s lanes. The x86-64 backend uses an SSE2 sequence that derives a borrow mask and selects zero. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U64x2) return U64x2

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqsub instruction over 2d lanes. The x86-64 backend uses an SSE2 sequence that derives a borrow mask and selects zero. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Saturate

function Subtract_Saturate (Left, Right : U8x16) return U8x16

Subtract corresponding lanes and clamp to the lane range. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON uqsub instruction over 16b lanes. The x86-64 backend uses one SSE2 psubusb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I16x8) return I16x8

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 8h lanes. The x86-64 backend uses the SSE2 psubw instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I32x4) return I32x4

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 4s lanes. The x86-64 backend uses the SSE2 psubd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I64x2) return I64x2

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 2d lanes. The x86-64 backend uses the SSE2 psubq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : I8x16) return I8x16

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 16b lanes. The x86-64 backend uses the SSE2 psubb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U16x8) return U16x8

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U32x4) return U32x4

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 4s lanes. The x86-64 backend uses the SSE2 psubd instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U64x2) return U64x2

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 2d lanes. The x86-64 backend uses the SSE2 psubq instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Subtract_Wrap

function Subtract_Wrap (Left, Right : U8x16) return U8x16

Subtract corresponding lanes modulo the lane width. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sub instruction over 16b lanes. The x86-64 backend uses the SSE2 psubb instruction. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Table_Lookup

function Table_Lookup (Table, Indices : U8x16) return U8x16

Use the unsigned value in each index lane for the corresponding result lane. A value from zero through 15 selects the table lane with the same lane index. A larger value returns zero. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses one NEON tbl instruction. The x86-64 backend uses an SSE2 sequence that compares each index with every valid table position, broadcasts the matching table byte, masks it, and merges all matches into an initially zero result. Indexes above 15 match no position and remain zero. A scalar build uses the portable scalar implementation.

Parameters

Table: The 16 selectable byte lanes.
Indices: One unsigned table index for each result lane.

Return value

The operation result.

Test

function Test (Mask : Mask_16x8; Lane : Lane_Index_16x8) return Boolean

Return the Boolean truth of one mask lane. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

Test

function Test (Mask : Mask_32x4; Lane : Lane_Index_32x4) return Boolean

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

Test

function Test (Mask : Mask_64x2; Lane : Lane_Index_64x2) return Boolean

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

Test

function Test (Mask : Mask_8x16; Lane : Lane_Index_8x16) return Boolean

Parameters

Mask: The input mask.
Lane: The logical lane index.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_16x8) return Interfaces.Unsigned_8

Return compact lane truths. Bit zero represents lane zero. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends apply this operation directly to the fixed-width compact integer mask. No vector instruction is required. A scalar build uses the portable scalar implementation.

Parameters

Mask: The input mask.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_32x4) return Interfaces.Unsigned_8

Parameters

Mask: The input mask.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_64x2) return Interfaces.Unsigned_8

Parameters

Mask: The input mask.

Return value

The operation result.

To_Bit_Mask

function To_Bit_Mask (Mask : Mask_8x16) return Interfaces.Unsigned_16

Parameters

Mask: The input mask.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : F32x4) return Lane_Values_F32x4

Return all lanes in logical lane order. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 and x86-64 backends copy private vector storage into the result lane array directly with fixed-width Ada code. They do not call the portable root operation. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : F64x2) return Lane_Values_F64x2

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I16x8) return Lane_Values_I16x8

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I32x4) return Lane_Values_I32x4

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I64x2) return Lane_Values_I64x2

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : I8x16) return Lane_Values_I8x16

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U16x8) return Lane_Values_U16x8

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U32x4) return Lane_Values_U32x4

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U64x2) return Lane_Values_U64x2

Parameters

Value: The input value.

Return value

The operation result.

To_Lanes

function To_Lanes (Value : U8x16) return Lane_Values_8x16

Parameters

Value: The input value.

Return value

The operation result.

Two_Source_Lane_Map_16x8

type Two_Source_Lane_Map_16x8 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Map_32x4

type Two_Source_Lane_Map_32x4 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Map_64x2

type Two_Source_Lane_Map_64x2 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Map_8x16

type Two_Source_Lane_Map_8x16 is private;

A private, reusable result-lane to two-source-lane map.

Two_Source_Lane_Selector_16x8

type Two_Source_Lane_Selector_16x8 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selector_32x4

type Two_Source_Lane_Selector_32x4 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selector_64x2

type Two_Source_Lane_Selector_64x2 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selector_8x16

type Two_Source_Lane_Selector_8x16 is private;

Select one lane from the left or right source vector.

Two_Source_Lane_Selectors_16x8

type Two_Source_Lane_Selectors_16x8 is array (Lane_Index_16x8) of Two_Source_Lane_Selector_16x8;

One two-source selector for each result lane.

Two_Source_Lane_Selectors_32x4

type Two_Source_Lane_Selectors_32x4 is array (Lane_Index_32x4) of Two_Source_Lane_Selector_32x4;

One two-source selector for each result lane.

Two_Source_Lane_Selectors_64x2

type Two_Source_Lane_Selectors_64x2 is array (Lane_Index_64x2) of Two_Source_Lane_Selector_64x2;

One two-source selector for each result lane.

Two_Source_Lane_Selectors_8x16

type Two_Source_Lane_Selectors_8x16 is
  array (Lane_Index_8x16) of Two_Source_Lane_Selector_8x16;

One two-source selector for each result lane.

U16

subtype U16 is Interfaces.Unsigned_16;

Public lane, array, vector, or mask type U16.

U16_Array

type U16_Array is array (Natural range <>) of aliased U16;

Public lane, array, vector, or mask type U16_Array.

U16x8

type U16x8 is private;

Public lane, array, vector, or mask type U16x8.

U32

subtype U32 is Interfaces.Unsigned_32;

Public lane, array, vector, or mask type U32.

U32_Array

type U32_Array is array (Natural range <>) of aliased U32;

Public lane, array, vector, or mask type U32_Array.

U32x4

type U32x4 is private;

Public lane, array, vector, or mask type U32x4.

U64

subtype U64 is Interfaces.Unsigned_64;

Public lane, array, vector, or mask type U64.

U64_Array

type U64_Array is array (Natural range <>) of aliased U64;

Public lane, array, vector, or mask type U64_Array.

U64x2

type U64x2 is private;

Public lane, array, vector, or mask type U64x2.

U8

subtype U8 is Interfaces.Unsigned_8;

Public lane, array, vector, or mask type U8.

U8x16

type U8x16 is private;

Public lane, array, vector, or mask type U8x16.

Unordered

function Unordered (Left, Right : F32x4) return Mask_32x4

Return true in lanes where either floating input is NaN. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON sequence that compares each input with itself to mark lanes that are not NaN. It combines the masks with bitwise AND and inverts the result. The x86-64 backend uses a dedicated SSE2 unordered comparison. A scalar build uses the portable scalar implementation.

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Unordered

function Unordered (Left, Right : F64x2) return Mask_64x2

Parameters

Left: The left input.
Right: The right input.

Return value

The operation result.

Widen_High

function Widen_High (Value : F32x4) return F64x2

With the platform's default gradual-underflow environment, convert the high binary32 source half exactly to binary64. Signed zero and infinity are preserved. A NaN produces a NaN with unspecified payload and signaling state. The operation can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON instruction that converts the selected lanes with fcvtl2. The x86-64 backend uses a dedicated SSE2 sequence that shuffles the upper lanes and converts them with cvtps2pd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : I16x8) return I32x4

Convert the high source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sshll2 instruction over 4s lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using pcmpgtw to form a sign mask, then punpckhwd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : I32x4) return I64x2

Convert the high source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sshll2 instruction over 2d lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using pcmpgtd to form a sign mask, then punpckhdq. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : I8x16) return I16x8

Convert the high source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sshll2 instruction over 8h lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using pcmpgtb to form a sign mask, then punpckhbw. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : U16x8) return U32x4

Convert the high source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ushll2 instruction over 4s lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using punpckhwd with a zero vector. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : U32x4) return U64x2

Convert the high source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ushll2 instruction over 2d lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using punpckhdq with a zero vector. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_High

function Widen_High (Value : U8x16) return U16x8

Convert the high source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ushll2 instruction over 8h lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using punpckhbw with a zero vector. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : F32x4) return F64x2

With the platform's default gradual-underflow environment, convert the low binary32 source half exactly to binary64. Signed zero and infinity are preserved. A NaN produces a NaN with unspecified payload and signaling state. The operation can update floating-point exception-status flags. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses a dedicated NEON instruction that converts the selected lanes with fcvtl. The x86-64 backend uses a dedicated SSE2 instruction that converts the selected lanes with cvtps2pd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I16x8) return I32x4

Convert the low source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sshll instruction over 4s lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using pcmpgtw to form a sign mask, then punpcklwd. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I32x4) return I64x2

Convert the low source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sshll instruction over 2d lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using pcmpgtd to form a sign mask, then punpckldq. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : I8x16) return I16x8

Convert the low source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON sshll instruction over 8h lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using pcmpgtb to form a sign mask, then punpcklbw. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U16x8) return U32x4

Convert the low source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ushll instruction over 4s lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using punpcklwd with a zero vector. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U32x4) return U64x2

Convert the low source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ushll instruction over 2d lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using punpckldq with a zero vector. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Widen_Low

function Widen_Low (Value : U8x16) return U16x8

Convert the low source half according to the documented widening semantics. Cross-platform support: This overload uses the portable scalar implementation on every supported GNAT target. For the matching Native overload, the AArch64 backend uses the NEON ushll instruction over 8h lanes with a zero shift. The x86-64 backend uses an SSE2 sequence using punpcklbw with a zero vector. A scalar build uses the portable scalar implementation.

Parameters

Value: The input value.

Return value

The operation result.

Zero

function Zero return F32x4

function Zero return U8x16

Return value

The operation result.