AdvSimd.Store Metodo

Definizione

Spazio dei nomi:

System.Runtime.Intrinsics.Arm

Assembly:

System.Runtime.Intrinsics.dll

Overload

Store(Single*, Vector128<Single>)	void vst1q_f32 (float32_t * ptr, float32x4_t val) A32: VST1.32 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.4S }, [Xn]
Store(Single*, Vector64<Single>)	void vst1_f32 (float32_t * ptr, float32x2_t val) A32: VST1.32 { Dd }, [Rn] A64: ST1 { Vt.2S }, [Xn]
Store(UInt16*, Vector128<UInt16>)	void vst1q_u16 (uint16_t * ptr, uint16x8_t val) A32: VST1.16 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.8H }, [Xn]
Store(UInt16*, Vector64<UInt16>)	void vst1_u16 (uint16_t * ptr, uint16x4_t val) A32: VST1.16 { Dd }, [Rn] A64: ST1 { Vt.4H }, [Xn]
Store(Int16*, Vector64<Int16>)	void vst1_s16 (int16_t * ptr, int16x4_t val) A32: VST1.16 { Dd }, [Rn] A64: ST1 {Vt.4H }, [Xn]
Store(UInt32*, Vector128<UInt32>)	void vst1q_u32 (uint32_t * ptr, uint32x4_t val) A32: VST1.32 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.4S }, [Xn]
Store(UInt32*, Vector64<UInt32>)	void vst1_u32 (uint32_t * ptr, uint32x2_t val) A32: VST1.32 { Dd }, [Rn] A64: ST1 { Vt.2S }, [Xn]
Store(UInt64*, Vector128<UInt64>)	void vst1q_u64 (uint64_t * ptr, uint64x2_t val) A32: VST1.64 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.2D }, [Xn]
Store(UInt64*, Vector64<UInt64>)	void vst1_u64 (uint64_t * ptr, uint64x1_t val) A32: VST1.64 { Dd }, [Rn] A64: ST1 { Vt.1D }, [Xn]
Store(Int16*, Vector128<Int16>)	void vst1q_s16 (int16_t * ptr, int16x8_t val) A32: VST1.16 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.8H }, [Xn]
Store(SByte*, Vector128<SByte>)	void vst1q_s8 (int8_t * ptr, int8x16_t val) A32: VST1.8 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.16B }, [Xn]
Store(SByte*, Vector64<SByte>)	void vst1_s8 (int8_t * ptr, int8x8_t val) A32: VST1.8 { Dd }, [Rn] A64: ST1 { Vt.8B }, [Xn]
Store(Byte*, Vector64<Byte>)	void vst1_u8 (uint8_t * ptr, uint8x8_t val) A32: VST1.8 { Dd }, [Rn] A64: ST1 { Vt.8B }, [Xn]
Store(Double*, Vector128<Double>)	void vst1q_f64 (float64_t * ptr, float64x2_t val) A32: VST1.64 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.2D }, [Xn]
Store(Double*, Vector64<Double>)	void vst1_f64 (float64_t * ptr, float64x1_t val) A32: VST1.64 { Dd }, [Rn] A64: ST1 { Vt.1D }, [Xn]
Store(Byte*, Vector128<Byte>)	void vst1q_u8 (uint8_t * ptr, uint8x16_t val) A32: VST1.8 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.16B }, [Xn]
Store(Int64*, Vector128<Int64>)	void vst1q_s64 (int64_t * ptr, int64x2_t val) A32: VST1.64 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.2D }, [Xn]
Store(Int64*, Vector64<Int64>)	void vst1_s64 (int64_t * ptr, int64x1_t val) A32: VST1.64 { Dd }, [Rn] A64: ST1 { Vt.1D }, [Xn]
Store(Int32*, Vector64<Int32>)	void vst1_s32 (int32_t * ptr, int32x2_t val) A32: VST1.32 { Dd }, [Rn] A64: ST1 { Vt.2S }, [Xn]
Store(Int32*, Vector128<Int32>)	void vst1q_s32 (int32_t * ptr, int32x4_t val) A32: VST1.32 { Dd, Dd+1 }, [Rn] A64: ST1 { Vt.4S }, [Xn]

Store(Single*, Vector128<Single>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_f32 (float32_t * ptr, float32x4_t val)

A32: VST1.32 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.4S }, [Xn]

public:
 static void Store(float* address, System::Runtime::Intrinsics::Vector128<float> source);

public static void Store (float* address, System.Runtime.Intrinsics.Vector128<float> source);

static member Store : nativeptr<single> * System.Runtime.Intrinsics.Vector128<single> -> unit

Parametri

address

Single*

source

Vector128<Single>

Store(Single*, Vector64<Single>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_f32 (float32_t * ptr, float32x2_t val)

A32: VST1.32 { Dd }, [Rn]

A64: ST1 { Vt.2S }, [Xn]

public:
 static void Store(float* address, System::Runtime::Intrinsics::Vector64<float> source);

public static void Store (float* address, System.Runtime.Intrinsics.Vector64<float> source);

static member Store : nativeptr<single> * System.Runtime.Intrinsics.Vector64<single> -> unit

Parametri

address

Single*

source

Vector64<Single>

Store(UInt16*, Vector128<UInt16>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_u16 (uint16_t * ptr, uint16x8_t val)

A32: VST1.16 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.8H }, [Xn]

public:
 static void Store(System::UInt16* address, System::Runtime::Intrinsics::Vector128<System::UInt16> source);

public static void Store (ushort* address, System.Runtime.Intrinsics.Vector128<ushort> source);

static member Store : nativeptr<uint16> * System.Runtime.Intrinsics.Vector128<uint16> -> unit

Parametri

address

UInt16*

source

Vector128<UInt16>

Store(UInt16*, Vector64<UInt16>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_u16 (uint16_t * ptr, uint16x4_t val)

A32: VST1.16 { Dd }, [Rn]

A64: ST1 { Vt.4H }, [Xn]

public:
 static void Store(System::UInt16* address, System::Runtime::Intrinsics::Vector64<System::UInt16> source);

public static void Store (ushort* address, System.Runtime.Intrinsics.Vector64<ushort> source);

static member Store : nativeptr<uint16> * System.Runtime.Intrinsics.Vector64<uint16> -> unit

Parametri

address

UInt16*

source

Vector64<UInt16>

Store(Int16*, Vector64<Int16>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_s16 (int16_t * ptr, int16x4_t val)

A32: VST1.16 { Dd }, [Rn]

A64: ST1 {Vt.4H }, [Xn]

public:
 static void Store(short* address, System::Runtime::Intrinsics::Vector64<short> source);

public static void Store (short* address, System.Runtime.Intrinsics.Vector64<short> source);

static member Store : nativeptr<int16> * System.Runtime.Intrinsics.Vector64<int16> -> unit

Parametri

address

Int16*

source

Vector64<Int16>

Store(UInt32*, Vector128<UInt32>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_u32 (uint32_t * ptr, uint32x4_t val)

A32: VST1.32 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.4S }, [Xn]

public:
 static void Store(System::UInt32* address, System::Runtime::Intrinsics::Vector128<System::UInt32> source);

public static void Store (uint* address, System.Runtime.Intrinsics.Vector128<uint> source);

static member Store : nativeptr<uint32> * System.Runtime.Intrinsics.Vector128<uint32> -> unit

Parametri

address

UInt32*

source

Vector128<UInt32>

Store(UInt32*, Vector64<UInt32>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_u32 (uint32_t * ptr, uint32x2_t val)

A32: VST1.32 { Dd }, [Rn]

A64: ST1 { Vt.2S }, [Xn]

public:
 static void Store(System::UInt32* address, System::Runtime::Intrinsics::Vector64<System::UInt32> source);

public static void Store (uint* address, System.Runtime.Intrinsics.Vector64<uint> source);

static member Store : nativeptr<uint32> * System.Runtime.Intrinsics.Vector64<uint32> -> unit

Parametri

address

UInt32*

source

Vector64<UInt32>

Store(UInt64*, Vector128<UInt64>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_u64 (uint64_t * ptr, uint64x2_t val)

A32: VST1.64 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.2D }, [Xn]

public:
 static void Store(System::UInt64* address, System::Runtime::Intrinsics::Vector128<System::UInt64> source);

public static void Store (ulong* address, System.Runtime.Intrinsics.Vector128<ulong> source);

static member Store : nativeptr<uint64> * System.Runtime.Intrinsics.Vector128<uint64> -> unit

Parametri

address

UInt64*

source

Vector128<UInt64>

Store(UInt64*, Vector64<UInt64>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_u64 (uint64_t * ptr, uint64x1_t val)

A32: VST1.64 { Dd }, [Rn]

A64: ST1 { Vt.1D }, [Xn]

public:
 static void Store(System::UInt64* address, System::Runtime::Intrinsics::Vector64<System::UInt64> source);

public static void Store (ulong* address, System.Runtime.Intrinsics.Vector64<ulong> source);

static member Store : nativeptr<uint64> * System.Runtime.Intrinsics.Vector64<uint64> -> unit

Parametri

address

UInt64*

source

Vector64<UInt64>

Store(Int16*, Vector128<Int16>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_s16 (int16_t * ptr, int16x8_t val)

A32: VST1.16 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.8H }, [Xn]

public:
 static void Store(short* address, System::Runtime::Intrinsics::Vector128<short> source);

public static void Store (short* address, System.Runtime.Intrinsics.Vector128<short> source);

static member Store : nativeptr<int16> * System.Runtime.Intrinsics.Vector128<int16> -> unit

Parametri

address

Int16*

source

Vector128<Int16>

Store(SByte*, Vector128<SByte>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_s8 (int8_t * ptr, int8x16_t val)

A32: VST1.8 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.16B }, [Xn]

public:
 static void Store(System::SByte* address, System::Runtime::Intrinsics::Vector128<System::SByte> source);

public static void Store (sbyte* address, System.Runtime.Intrinsics.Vector128<sbyte> source);

static member Store : nativeptr<sbyte> * System.Runtime.Intrinsics.Vector128<sbyte> -> unit

Parametri

address

SByte*

source

Vector128<SByte>

Store(SByte*, Vector64<SByte>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_s8 (int8_t * ptr, int8x8_t val)

A32: VST1.8 { Dd }, [Rn]

A64: ST1 { Vt.8B }, [Xn]

public:
 static void Store(System::SByte* address, System::Runtime::Intrinsics::Vector64<System::SByte> source);

public static void Store (sbyte* address, System.Runtime.Intrinsics.Vector64<sbyte> source);

static member Store : nativeptr<sbyte> * System.Runtime.Intrinsics.Vector64<sbyte> -> unit

Parametri

address

SByte*

source

Vector64<SByte>

Store(Byte*, Vector64<Byte>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_u8 (uint8_t * ptr, uint8x8_t val)

A32: VST1.8 { Dd }, [Rn]

A64: ST1 { Vt.8B }, [Xn]

public:
 static void Store(System::Byte* address, System::Runtime::Intrinsics::Vector64<System::Byte> source);

public static void Store (byte* address, System.Runtime.Intrinsics.Vector64<byte> source);

static member Store : nativeptr<byte> * System.Runtime.Intrinsics.Vector64<byte> -> unit

Parametri

address

Byte*

source

Vector64<Byte>

Store(Double*, Vector128<Double>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_f64 (float64_t * ptr, float64x2_t val)

A32: VST1.64 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.2D }, [Xn]

public:
 static void Store(double* address, System::Runtime::Intrinsics::Vector128<double> source);

public static void Store (double* address, System.Runtime.Intrinsics.Vector128<double> source);

static member Store : nativeptr<double> * System.Runtime.Intrinsics.Vector128<double> -> unit

Parametri

address

Double*

source

Vector128<Double>

Store(Double*, Vector64<Double>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_f64 (float64_t * ptr, float64x1_t val)

A32: VST1.64 { Dd }, [Rn]

A64: ST1 { Vt.1D }, [Xn]

public:
 static void Store(double* address, System::Runtime::Intrinsics::Vector64<double> source);

public static void Store (double* address, System.Runtime.Intrinsics.Vector64<double> source);

static member Store : nativeptr<double> * System.Runtime.Intrinsics.Vector64<double> -> unit

Parametri

address

Double*

source

Vector64<Double>

Store(Byte*, Vector128<Byte>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_u8 (uint8_t * ptr, uint8x16_t val)

A32: VST1.8 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.16B }, [Xn]

public:
 static void Store(System::Byte* address, System::Runtime::Intrinsics::Vector128<System::Byte> source);

public static void Store (byte* address, System.Runtime.Intrinsics.Vector128<byte> source);

static member Store : nativeptr<byte> * System.Runtime.Intrinsics.Vector128<byte> -> unit

Parametri

address

Byte*

source

Vector128<Byte>

Store(Int64*, Vector128<Int64>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_s64 (int64_t * ptr, int64x2_t val)

A32: VST1.64 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.2D }, [Xn]

public:
 static void Store(long* address, System::Runtime::Intrinsics::Vector128<long> source);

public static void Store (long* address, System.Runtime.Intrinsics.Vector128<long> source);

static member Store : nativeptr<int64> * System.Runtime.Intrinsics.Vector128<int64> -> unit

Parametri

address

Int64*

source

Vector128<Int64>

Store(Int64*, Vector64<Int64>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_s64 (int64_t * ptr, int64x1_t val)

A32: VST1.64 { Dd }, [Rn]

A64: ST1 { Vt.1D }, [Xn]

public:
 static void Store(long* address, System::Runtime::Intrinsics::Vector64<long> source);

public static void Store (long* address, System.Runtime.Intrinsics.Vector64<long> source);

static member Store : nativeptr<int64> * System.Runtime.Intrinsics.Vector64<int64> -> unit

Parametri

address

Int64*

source

Vector64<Int64>

Store(Int32*, Vector64<Int32>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1_s32 (int32_t * ptr, int32x2_t val)

A32: VST1.32 { Dd }, [Rn]

A64: ST1 { Vt.2S }, [Xn]

public:
 static void Store(int* address, System::Runtime::Intrinsics::Vector64<int> source);

public static void Store (int* address, System.Runtime.Intrinsics.Vector64<int> source);

static member Store : nativeptr<int> * System.Runtime.Intrinsics.Vector64<int> -> unit

Parametri

address

Int32*

source

Vector64<Int32>

Store(Int32*, Vector128<Int32>)

Origine:

AdvSimd.PlatformNotSupported.cs

void vst1q_s32 (int32_t * ptr, int32x4_t val)

A32: VST1.32 { Dd, Dd+1 }, [Rn]

A64: ST1 { Vt.4S }, [Xn]

public:
 static void Store(int* address, System::Runtime::Intrinsics::Vector128<int> source);

public static void Store (int* address, System.Runtime.Intrinsics.Vector128<int> source);

static member Store : nativeptr<int> * System.Runtime.Intrinsics.Vector128<int> -> unit

Parametri

address

Int32*

source

Vector128<Int32>