Skip to content
Vector library for porting SSE2 instructions to other architectures
C
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.gitignore
LICENSE
README.md
vec128intlib.c
vec128intlib.h

README.md

veclib

Vector library for porting SSE2 instructions to other architectures

Credit to yhcheng for first providing a PPC64 port of the Burrows-Wheeler Aligner which helped me expand on the instructions. PPC64 Altivec instructions are provided in vec128int.h which depends on veclib_types.h.

To use in a project that uses SSE2 instructions simply place vec128int.h, vec128intlib.c, vec128intlib.h, and vec_libtypes.h in the same directory your C/C++ source file calling SSE2 instructions is in. Replace all instances of #include <emmintrin.h> with #include "vec128intlib.h". Add vec128intlib.o to the makefile and it should compile fine. Note that not all SSE2 instructions have been ported over so you may get errors for those functions. Also some instructions only work on POWER8 or newer. Those instructions are marked in vec128intlib.c and vec128intlib.h.

The IBM POWER vector intrinsinc functions library can be downloaded from the IBM developerWorks website.

Below are some integer SSE2 instructions I've managed to port to Altivec using veclib-1.0.4.

For big-endian platforms only the shift left/right operations are reversed.

Vector Integer Operations

Load

veclib SSE2 Altivec Description
_mm_load_si128 (__m128i const* mem_addr) vec_load1q Load 128 bits of integer data, aligned
_mm_loadu_si128 (__m128i const* mem_addr) vec_loadu1q Load 128 bits of integer data, unaligned
_mm_loadl_epi64 (__m128i const* mem_addr) vec_loadlower1sd Load 64-bits of integer data to lower part and zero upper part

Set

veclib SSE2 Altivec Description
_mm_setzero_si128 () vec_zero1q Set 128 integer bits to zero
_mm_set1_epi8 (char a) vec_splat16sb Splat 8-bit char to 16 8-bit chars
_mm_set1_epi16 (short a) vec_splat8sh Splat 16-bit short to 8 16-bit shorts
_mm_set1_epi32 (int a) vec_splat4sw Splat 32-bit ints to 4 32-bit ints
_mm_set1_epi64 (__m64 a) vec_splat2sd Splat 64-bit long long to 2 64-bit long longs
_mm_set_epi8 (char a) vec_set16sb Set 16 8-bit chars
_mm_set_epi16 (short a) vec_set8sh Set 8 16-bits shorts
_mm_set_epi32 (int a) vec_set4sw Set 4 32-bit ints
_mm_set_epi64 (__m64 a) vec_set2sd Set 2 64-bit long longs
_mm_setr_epi8 (char a) vec_setreverse16sb Set 16 8-bit chars reversed
_mm_setr_epi16 (short a) vec_setreverse8sh Set 8 16-bit shorts reversed
_mm_setr_epi32 (int a) vec_setreverse4sw Set 4 32-bit ints reversed
_mm_setr_epi64 (__m64 a) vec_setreverse2sd Set 2 64-bit long longs reversed
_mm_movpi64_epi64 (__m64 a) vec_Zerouppersd Set lower 64-bits of integer data and zero upper part

Store

veclib SSE2 Altivec Description
_mm_store_si128 (__m128i* mem_addr, __m128i a) vec_store1q Store 128-bits integer, aligned
_mm_storeu_si128 (__mm128i* mem_addr, __m128i a) vec_storeu1q Store 128-bits integer, unaligned
_mm_storel_epi64 (__m128i* mem_addr, __m128i a) vec_storelower1sdof2sd Store lower 64-bit long long

Insert

veclib SSE2 Altivec Description
vec_insert4sw (__m128i into, int from, const intlit2 element_from_right) Insert 32-bit int
vec_insert2sd (__m128i into, long long from, const intlit1 element_from_right) Insert 64-bit long long
vec_convert1swto1uq (int from) Insert 32-bit int, zeroing upper
_mm_insert_epi16 (__m128i a, int i, int imm8) vec_insert8sh Insert 16-bit short into one of 8 16-bit shorts
vec_insert16ub (__m128i v, int scalar, intlit4 element_from_right) Insert 8-bit unsigned char into one of 16 bytes

Extract

veclib SSE2 Altivec Description
vec_extract1swfrom4sw (__m128i from, const intlit2 element_from_right) Extract 32-bit int
vec_extract1sdfrom2sd (__m128i from, const intlit1 element_from_right) Extract 64-bit long long
_mm_extract_epi16 (__m128i a, int imm8) vec_extract8sh Extract 16-bit short from one of 8 16-bit shorts
_mm_movemask_epi8 (__m128i a) vec_extractupperbit16sb Extract upper bit of 16 8-bit chars
vec_extractupperbit2dp (__m128d v) Extract upper bit of 2 64-bit doubles
vec_extractlowersw (__m128i from) Extract lower 32-bit int

Convert integer to integer

veclib SSE2 Altivec Description
_mm_packs_epi16 (__m128i a, __m128i b) vec_packs8hto16sb Convert 8+8 16-bit shorts to 16 8-bit chars with signed saturation
_mm_packs_epi32 (__m128i a, __m128i b) vec_packs4wto8sh Convert 4+4 32-bit ints to 8 16-bit shorts with signed saturation
_mm_packus_epi16 (__m128i a, __m128i b) Convert packed 16-bit integers from a and b to packed 8-bit integers using unsigned saturation, and store the results in dst

Convert floating-point to integer

veclib SSE2 Altivec Description
_mm_cvttps_epi32 (__m128 a) vec_converttruncating4spto4sw Convert 4 32-bit floats to 4 32-bit ints with truncation
_mm_cvtps_epi32 (__m128 a) vec_convert4spto4sw Convert 4 32-bit floats to 4 32-bit ints
_mm_cvttpd_epi32 (__m128d a) vec_Convert2dpto2sw Convert 2 64-bit doubles to 2 32-bit ints with truncation
_mm_cvtpd_epi32 (__m128d a) Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst
_mm_cvtsi32_si128 (int a) Copy 32-bit integer a to the lower element of dst, and zero the upper element
_mm_cvtsi64_si128 (int64 a) Copy 64-bit integer a to the lower element of dst, and zero the upper element

Arithmetic

veclib SSE2 Altivec Description
_mm_add_epi8 (__m128i a, __m128i b) vec_add16sb Add 16 8-bit chars
_mm_add_epi16 (__m128i a, __m128i b) vec_add8sh Add 8 16-bit shorts
_mm_add_epi32 (__m128i a, __m128i b) vec_add4sw Add 4 32-bit ints
_mm_add_epi64 (__m128i a, __m128i b) vec_add2sd Add 2 64-bit long longs
_mm_adds_epi8 (__m128i a, __m128i b) vec_addsaturating16sb Add 16 8-bit chars with signed saturation
_mm_adds_epu8 (__m128i a, __m128i b) vec_addsaturating16ub Add 16 8-bit chars with unsigned saturation
_mm_adds_epi16 (__m128i a, __m128i b) vec_addsaturating8sh Add 8 16-bit shorts with signed saturation
_mm_adds_epu16 (__m128i a, __m128i b) vec_addsaturating8uh Add 8 16-bit shorts with unsigned saturation
_mm_sub_epi8 (__m128i a, __m128i b) vec_subtract16sb Subtract 16 8-bit chars
_mm_sub_epi16 (__m128i a, __m128i b) vec_subtract8sh Subtract 8 16-bit shorts
_mm_sub_epi32 (__m128i a, __m128i b) vec_subtract4sw Subtract 4 32-bit ints
_mm_sub_epi64 (__m128i a, __m128i b) vec_subtract2sd Subtract 2 64-bit long longs
_mm_subs_epi8 (__m128i a, __m128i b) vec_subtractsaturating16sb Subtract 16 8-bit chars with signed saturation
_mm_subs_epu8 (__m128i a, __m128i b) vec_subtractsaturating16ub Subtract 16 8-bit chars with unsigned saturation
_mm_subs_epi16 (__m128i a, __m128i b) vec_subtractsaturating8sh Subtract 8 16-bit shorts with signed saturation
_mm_subs_epu16 (__m128i a, __m128i b) vec_subtractsaturating8uh Subtract 8 16-bit shorts with unsigned saturation
_mm_mul_epu32 (__m128i a, __m128i b) vec_multiplylower2uwto2ud Multiply lower 32-bit unsigned ints producing 2 64-bit unsigned long longs
_mm_madd_epi16 (__m128i a, __m128i b) vec_multiply8sh Multiply 8 16-bit signed shorts
_mm_mulhi_epi16 (__m128i a, __m128i b) Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst
_mm_mulhi_epu16 (__m128i a, __m128i b) Multiply the packed unsigned 16-bit integers in a and b, producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in dst
_mm_mullo_epi16 (__m128i a, __m128i b) Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in dst
_mm_avg_epu8 (__m128i a, __m128i b) vec_average16ub Average 16 8-bit unsigned chars
_mm_avg_epu16 (__m128i a, __m128i b) vec_average8uh Average 8 16-bit unsigned shorts
_mm_max_epi16 (__m128i a, __m128i b) vec_max8sh Max 8 16-bit shorts
_mm_max_epu8 (__m128i a, __m128i b) vec_max16ub Max 16 8-bit unsigned chars
_mm_min_epu8 (__m128i a, __m128i b) vec_min16ub Min 16 8-bit unsigned chars
_mm_min_epi16 (__m128i a, __m128i b) vec_min8sh Min 8 16-bit shorts
vec_sumabsdiffs16ub (__m128i left, __m128i right) Sum 2 octets of absolute differences of 16 8-bit unsigned chars into 2 64-bit long longs
vec_summultiply4sh (__m128i left, __m128i right) Multiply 4 16-bit shorts then add adjacent pairs with saturation to 4 32-bit ints
vec_Abs16sb (__m128i a) Absolute value 16 8-bit chars
vec_Abs8sh (__m128i a) Absolute value 8 16-bit shorts
vec_Abs4sw (__m128i a) Absolute value 4 32-bit ints
vec_horizontalAddsaturating8sh (__m128i left, __m128i right) Horizontally add 4+4 adjacent pairs of 16-bit shorts with saturation - (a0+a1, a2+a3, a4+a5, a6+a7, b0+b1, b2+b3, b4+b5, b6+b7)
vec_horizontalSub8sh (__m128i left, __m128i right) Horizontally subtract 4+4 adjacent pairs of 16-bit shorts to 8 16-bit shorts - (a0-a1, a2-a3, a4-a5, a6-a7, b0-b1, b2-b3, b4-b5, b6-b7)
vec_partialhorizontalsubtract2sw (__m128i left, __m128i right) Horizontally subtract 2+2 adjacent pairs of 32-bit ints to 4 32-bit ints
vec_horizontalSubtractsaturating8sh (__m128i left, __m128i right) Horizontally subtract 4+4 adjacent pairs of 16-bit shorts to 8-bit shorts with saturation - (a0+a1, a2+a3, a4+a5, a6+a7, b0+b1, b2+b3, b4+b5, b6+b7)
vec_Multiply16sbthenhorizontalAddsaturating8sh (__m128i left, __m128i right) Multiply 16 8-bit u*s chars then add adjacent 16-bit products with signed saturation
vec_Multiply8shExtractUpper (__m128i left, __m128i right) Multiply 8 16-bit shorts, shift right 14, add 1 and shift right 1 to 8 16-bit shorts
vec_conditionalNegate16sb (__m128i left, __m128i right) Negate 16 8-bit chars when mask is negative, zero when zero, else copy
vec_conditionalNegate8sh (__m128i left, __m128i right) Negate 8 16-bit shorts when mask is negative, zero when zero, else copy
vec_conditionalNegate4sw (__m128i left, __m128i right) Negate 4 32-bit ints when mask is negative, zero when zero, else copy
vec_multiply4sw (__m128i left, __m128i right) Multiply 4 32-bit signed ints
vec_Max4sw (__m128i left, __m128i right) Max 4 32-bit signed ints
vec_Min4sw (__m128i left, __m128i right) Min 4 32-bit signed ints

Boolean

veclib SSE2 Altivec Description
_mm_and_si128 (__m128i a, __m128i b) vec_bitand1q Bitwise 128-bit and
_mm_andnotsi128 (__m128i a, __m128i b) vec_bitandnotleft1q Bitwise 128-bit and not (reversed)
_mm_or_si128 (__m128i a, __m128i b) vec_bitor1q Bitwise 128-bit or
_mm_xor_si128 (__m128i a, __m128i b) vec_bitxor1q Bitwise 128-bit xor

Unpack

veclib SSE2 Altivec Description
_mm_unpackhi_epi8 (__m128i a, __m128i b) vec_unpackhigh8sb Unpack 8+8 8-bit chars from high halves and interleave
_mm_unpackhi_epi16 (__m128i a, __m128i b) vec_unpackhigh4sh Unpack 4+4 16-bit shorts from high halves and interleave
_mm_unpacklo_epi8 (__m128i a, __m128i b) vec_unpacklow8sb Unpack 8+8 8-bit chars from low halves and interleave
_mm_unpacklo_epi16 (__m128i a, __m128i b) vec_unpacklow4sh Unpack 4+4 16-bit shorts from low halves and interleave
_mm_unpacklo_epi32 (__m128i a, __m128i b) vec_unpacklow2sw Unpack 2+2 32-bit ints from low halves and interleave
_mm_unpackhi_epi32 (__m128i a, __m128i b) vec_unpackhigh2sw Unpack 2+2 32-bit ints from high halves and interleave
_mm_unpacklo_epi64 (__m128i a, __m128i b) vec_unpacklow1sd Unpack 1+1 64-bit long longs from low halves and interleave
_mm_unpackhi_epi64 (__m128i a, __m128i b) vec_unpackhigh1sd Unpack 1+1 64-bit long longs from high halves and interleave

Shift

veclib SSE2 Altivec Description
_mm_sll_epi16 (__m128i a, int imm8) vec_shiftleft8sh Shift 8 16-bit shorts left logical
_mm_sll_epi32 (__m128i a, int imm8) vec_shiftleft4sw Shift 4 32-bit ints left logical
_mm_sll_epi64 (__m128i a, int imm8) vec_shiftleft2sd Shift 2 64-bit long longs left logical
_mm_slli_epi16 (__m128i a, int imm8) vec_shiftleftimmediate8sh Shift 8 16-bit shorts left logical immediate
_mm_slli_epi32 (__m128i a, int imm8) vec_shiftleftimmediate4sw Shift 4 32-bit ints left logical immediate
_mm_slli_epi64 (__m128i a, int imm8) vec_shiftleftimmediate2sd Shift 2 64-bit long longs left logical immediate
_mm_slli_si128 (__m128i a, int imm8) vec_shiftleftbytes1q Shift 128-bits left logical immediate by bytes
_mm_srl_epi16 (__m128i a, int imm8) vec_shiftright8sh Shift 8 16-bit shorts right logical
_mm_srl_epi32 (__m128i a, int imm8) vec_shiftright4sw Shift 4 32-bit ints right logical
_mm_srl_epi64 (__m128i a, int imm8) vec_shiftright2sd Shift 2 64-bit long longs right logical
_mm_srli_epi16 (__m128i a, int imm8) vec_shiftrightimmediate8sh Shift 8 16-bit shorts right logical immediate
_mm_srli_epi32 (__m128i a, int imm8) vec_shiftrightimmediate4sw Shift 4 32-bit ints right logical immediate
_mm_srli_epi64 (__m128i a, int imm8) Shift 2 64-bit long longs right logical immediate
_mm_srli_si128 (__m128i a, int imm8) vec_shiftrightbytes1q Shift 128-bits right logical immediate by bytes
vec_shiftrightarithmetic4wimmediate (__m128i v, intlit8 count) Shift 4 32-bit ints right arithmetic
vec_shiftrightlogical2dimmediate (__m128i v, intlit8 count) Shift 2 64-bit long longs right logical immediate
vec_shiftrightarithmetic8himmediate (__m128i v, intlit8 count) Shift 8 16-bit shorts right arithmetic
vec_shiftrightarithmetic4sw (__m128i v, intlit8 count) Shift 4 32-bit ints left logical
vec_shiftright2dqw (__m128i left, __m128i right, int const count) Shift 128+128-bits right into 128-bits
_mm_bslli_si128 (__m128i a, int imm8) Shift a left by imm8 bytes while shifting in zeros, and store the results in dst
_mm_bsrli_si128 (__m128i a, int imm8) Shift a right by imm8 bytes while shifting in zeros, and store the results in dst

Permute

veclib SSE2 Altivec Description
_mm_shufflehi_epi16 (__m128i a, int imm8) Shuffle 16-bit integers in the high 64 bits of a using the control in imm8. Store the results in the high 64 bits of dst, with the low 64 bits being copied from from a to dst
_mm_shufflelo_epi16 vec_permutelower4sh Shuffle lower 4 16-bit shorts using mask, leaving upper half unchanged
_mm_shuffle_epi32 (__m128i a, int imm8) vec_permute4sw Shuffle 4 32-bit ints using mask
vec_permute16sb (__m128i v, __m128i mask) Shuffle 16 8-bit chars using mask

Compare

veclib SSE2 Altivec Description
_mm_cmpeq_epi8 (__m128i a, __m128i b) vec_compareeq16sb Compare 16 8-bit chars for == to vector mask
_mm_cmpeq_epi16 (__m128i a, __m128i b) vec_compareeq8sh Compare 8 16-bit shorts for == to vector mask
_mm_cmpeq_epi32 (__m128i a, __m128i b) vec_compareeq4sw Compare 4 32-bit ints for == to vector mask
_mm_cmplt_epi8 (__m128i a, __m128i b) vec_comparelt16sb Compare 16 8-bit chars for < to vector mask
_mm_cmplt_epi16 (__m128i a, __m128i b) vec_comparelt8sh Compare 8 16-bit shorts for < to vector mask
_mm_cmplt_epi32 (__m128i a, __m128i b) vec_comparelt4sw Compare 4 32-bit ints for < to vector mask
_mm_cmpgt_epi8 (__m128i a, __m128i b) vec_comparegt16sb Compare 16 8-bit chars for > to vector mask
_mm_cmpgt_epi16 (__m128i a, __m128i b) vec_comparegt8sh Compare 8 16-bit shorts for > to vector mask
_mm_cmpgt_epi32 (__m128i a, __m128i b) vec_comparegt4sw Compare 4 32-bit ints for > to vector mask

Cast

veclib SSE2 Altivec Description
_mm_castps_si128 (__m128 a) vec_cast4spto1q Cast __m128 to __m128i
_mm_castpd_si128 (__m128d a) vec_Cast2dpto4sw Cast __m128d to __m128i
You can’t perform that action at this time.