Memory and Initialization Using Streaming SIMD Extensions

This section describes the load, set, and store operations, which let you load and store data into memory. The load and set operations are similar in that both initialize __m128 data. However, the set operations take a float argument and are intended for initialization with constants, whereas the load operations take a floating point argument and are intended to mimic the instructions for loading data from memory. The store operation assigns the initialized data to the address.

The intrinsics are listed in the following table. Syntax and a brief description are contained the following topics.

The prototypes for Streaming SIMD Extensions intrinsics are in the xmmintrin.h header file.

__m128 _mm_load_ss(float const*a)

Loads an SP FP value into the low word and clears the upper three words.
r0 := *a
r1 := 0.0 ; r2 := 0.0 ; r3 := 0.0

__m128 _mm_load_ps1(float const*a)

Loads a single SP FP value, copying it into all four words.
r0 := *a
r1 := *a
r2 := *a
r3 := *a

__m128 _mm_load_ps(float const*a)

Loads four SP FP values. The address must be 16-byte-aligned.
r0 := a[0]
r1 := a[1]
r2 := a[2]
r3 := a[3]

__m128 _mm_loadu_ps(float const*a)

Loads four SP FP values. The address need not be 16-byte-aligned.
r0 := a[0]
r1 := a[1]
r2 := a[2]
r3 := a[3]

__m128 _mm_loadr_ps(float const*a)

Loads four SP FP values in reverse order. The address must be 16-byte-aligned.
r0 := a[3]
r1 := a[2]
r2 := a[1]
r3 := a[0]

__m128 _mm_set_ss(float a)

Sets the low word of an SP FP value to a and clears the upper three words.
r0 := c
r1 := r2 := r3 := 0.0

__m128 _mm_set_ps1(float a)

Sets the four SP FP values to a.
r0 := r1 := r2 := r3 := a

__m128 _mm_set_ps(float a, float b, float c, float d)

Sets the four SP FP values to the four inputs.
r0 := a
r1 := b
r2 := c
r3 := d

__m128 _mm_setr_ps(float a, float b, float c, float d)

Sets the four SP FP values to the four inputs in reverse order.
r0 := d
r1 := c
r2 := b
r3 := a

__m128 _mm_setzero_ps(void)

Clears the four SP FP values.
r0 := r1 := r2 := r3 := 0.0

void _mm_store_ss(float *v, __m128 a)

Stores the lower SP FP value.
*v := a0

void _mm_store_ps1(float *v, __m128 a)

Stores the lower SP FP value across four words.
v[0] := a0
v[1] := a0
v[2] := a0
v[3] := a0

void _mm_store_ps(float *v, __m128 a)

Stores four SP FP values. The address must be 16-byte-aligned.
v[0] := a0
v[1] := a1
v[2] := a2
v[3] := a3

void _mm_storeu_ps(float *v, __m128 a)

Stores four SP FP values. The address need not be 16-byte-aligned.
v[0] := a0
v[1] := a1
v[2] := a2
v[3] := a3

void _mm_storer_ps(float *v, __m128 a)

Stores four SP FP values in reverse order. The address must be 16-byte-aligned.
v[0] := a3
v[1] := a2
v[2] := a1
v[3] := a0

__m128 _mm_move_ss(__m128 a, __m128 b)

Sets the low word to the SP FP value of b. The upper 3 SP FP values are passed through from a.
r0 := b0
r1 := a1
r2 := a2
r3 := a3

unsigned int _mm_getcsr(void)

Returns the contents of the control register.

Sets the control register to the value specified.

void _mm_prefetch(char const*a, int sel)

(uses PREFETCH) Loads one cache line of data from address a to a location "closer" to the processor. The value sel specifies the type of prefetch operation: the constants _MM_HINT_T0, _MM_HINT_T1, _MM_HINT_T2, and _MM_HINT_NTA should be used, corresponding to the type of prefetch instruction.

(uses MOVNTQ) Stores the data in a to the address p without polluting the caches. This intrinsic requires you to empty the multimedia state for the mmx register. See The EMMS Instruction: Why You Need It and When to Use It topic.

(see MOVNTPS) Stores the data in a to the address p without polluting the caches. The address must be 16-byte-aligned.

(uses SFENCE) Guarantees that every preceding store is globally visible before any subsequent store.

This intrinsic extracts a single precision floating point value from the first vector element of an __m128. It does so in the most effecient manner possible in the context used. This intrinsic doesn't map to any specific SSE instruction.