|
|
|
1 |
|
/** |
2 |
|
*** Copyright (C) 1985-1999 Intel Corporation. All rights reserved. |
3 |
|
*** |
4 |
|
*** The information and source code contained herein is the exclusive |
5 |
|
*** property of Intel Corporation and may not be disclosed, examined |
6 |
|
*** or reproduced in whole or in part without explicit written authorization |
7 |
|
*** from the company. |
8 |
|
*** |
9 |
|
**/ |
10 |
|
|
11 |
|
/* |
12 |
|
* Definition of a C++ class interface to MMX(TM) instruction intrinsics. |
13 |
|
* |
14 |
|
*/ |
15 |
|
|
16 |
|
#ifndef _IVEC_H_INCLUDED |
17 |
|
#define _IVEC_H_INCLUDED |
18 |
|
#ifndef RC_INVOKED |
19 |
|
|
20 |
|
#if !defined __cplusplus |
21 |
|
#error ERROR: This file is only supported in C++ compilations! |
22 |
|
#endif /* !__cplusplus */ |
23 |
|
|
24 |
|
#if defined(_M_CEE_PURE) |
25 |
|
#error ERROR: This file is not supported in the pure mode! |
26 |
|
#else |
27 |
|
|
28 |
|
#include <mmintrin.h> |
29 |
|
#include <assert.h> |
30 |
|
|
31 |
|
/* |
32 |
|
* Define _SILENCE_IVEC_C4799 to disable warning C4799 inside this header. |
33 |
|
* Be careful that any code that uses these functions properly executes EMMS |
34 |
|
* or _m_empty() after using any MMX instruction and before using the x87 NDP. |
35 |
|
*/ |
36 |
|
#if defined(_SILENCE_IVEC_C4799) |
37 |
|
#pragma warning(push) |
38 |
|
#pragma warning(disable: 4799) |
39 |
|
#endif |
40 |
|
|
41 |
|
/* |
42 |
|
* Define _ENABLE_VEC_DEBUG to enable std::ostream inserters for debug output |
43 |
|
*/ |
44 |
|
#if defined(_ENABLE_VEC_DEBUG) |
45 |
|
#include <iostream> |
46 |
|
#endif |
47 |
|
|
48 |
|
#define EXPLICIT explicit |
49 |
|
|
50 |
|
class I8vec8; /* 8 elements, each element a signed or unsigned char data type */ |
51 |
|
class Is8vec8; /* 8 elements, each element a signed char data type */ |
52 |
|
class Iu8vec8; /* 8 elements, each element an unsigned char data type */ |
53 |
|
class I16vec4; /* 4 elements, each element a signed or unsigned short */ |
54 |
|
class Is16vec4; /* 4 elements, each element a signed short */ |
55 |
|
class Iu16vec4; /* 4 elements, each element an unsigned short */ |
56 |
|
class I32vec2; /* 2 elements, each element a signed or unsigned long */ |
57 |
|
class Is32vec2; /* 2 elements, each element a signed long */ |
58 |
|
class Iu32vec2; /* 2 elements, each element a unsigned long */ |
59 |
|
class I64vec1; /* 1 element, a __m64 data type - Base I64vec1 class */ |
60 |
|
|
61 |
|
#define _MM_8UB(element,vector) (*((unsigned char*)&##vector + ##element)) |
62 |
|
#define _MM_8B(element,vector) (*((signed char*)&##vector + ##element)) |
63 |
|
|
64 |
|
#define _MM_4UW(element,vector) (*((unsigned short*)&##vector + ##element)) |
65 |
|
#define _MM_4W(element,vector) (*((short*)&##vector + ##element)) |
66 |
|
|
67 |
|
#define _MM_2UDW(element,vector) (*((unsigned int*)&##vector + ##element)) |
68 |
|
#define _MM_2DW(element,vector) (*((int*)&##vector + ##element)) |
69 |
|
|
70 |
|
#define _MM_QW (*((__int64*)&vec)) |
71 |
|
|
72 |
|
/* M64 Class: |
73 |
|
* 1 element, a __m64 data type |
74 |
|
* Contructors & Logical Operations |
75 |
|
*/ |
76 |
|
class M64 |
77 |
|
{ |
78 |
|
protected: |
79 |
|
__m64 vec; |
80 |
|
|
81 |
|
public: |
82 |
|
M64() { } |
83 |
|
M64(__m64 mm) { vec = mm; } |
84 |
|
M64(__int64 mm) { _MM_QW = mm; } |
85 |
|
M64(int i) { vec = _m_from_int(i); } |
86 |
|
|
87 |
|
operator __m64() const { return vec; } |
88 |
|
|
89 |
|
/* Logical Operations */ |
90 |
|
M64& operator&=(const M64 &a) { return *this = (M64) _m_pand(vec,a); } |
91 |
|
M64& operator|=(const M64 &a) { return *this = (M64) _m_por(vec,a); } |
92 |
|
M64& operator^=(const M64 &a) { return *this = (M64) _m_pxor(vec,a); } |
93 |
|
|
94 |
|
}; |
95 |
|
|
96 |
|
inline M64 operator&(const M64 &a, const M64 &b) { return _m_pand( a,b); } |
97 |
|
inline M64 operator|(const M64 &a, const M64 &b) { return _m_por(a,b); } |
98 |
|
inline M64 operator^(const M64 &a, const M64 &b) { return _m_pxor(a,b); } |
99 |
|
inline M64 andnot(const M64 &a, const M64 &b) { return _m_pandn(a,b); } |
100 |
|
|
101 |
|
/* I64vec1 Class: |
102 |
|
* 1 element, a __m64 data type |
103 |
|
* Contains Operations which can operate on any __m64 data type |
104 |
|
*/ |
105 |
|
|
106 |
|
class I64vec1 : public M64 |
107 |
|
{ |
108 |
|
public: |
109 |
|
I64vec1() { } |
110 |
|
I64vec1(__m64 mm) : M64(mm) { } |
111 |
|
EXPLICIT I64vec1(int i) : M64(i) { } |
112 |
|
EXPLICIT I64vec1(__int64 mm) : M64(mm) { } |
113 |
|
|
114 |
|
I64vec1& operator= (const M64 &a) { return *this = (I64vec1) a; } |
115 |
|
I64vec1& operator&=(const M64 &a) { return *this = (I64vec1) _m_pand(vec,a); } |
116 |
|
I64vec1& operator|=(const M64 &a) { return *this = (I64vec1) _m_por(vec,a); } |
117 |
|
I64vec1& operator^=(const M64 &a) { return *this = (I64vec1) _m_pxor(vec,a); } |
118 |
|
|
119 |
|
/* Shift Logical Operations */ |
120 |
|
I64vec1 operator<<(const M64 &a) { return _m_psllq(vec, a); } |
121 |
|
I64vec1 operator<<(int count) { return _m_psllqi(vec, count); } |
122 |
|
I64vec1& operator<<=(const M64 &a) { return *this = (I64vec1) _m_psllq(vec, a); } |
123 |
|
I64vec1& operator<<=(int count) { return *this = (I64vec1) _m_psllqi(vec, count); } |
124 |
|
I64vec1 operator>>(const M64 &a) { return _m_psrlq(vec, a); } |
125 |
|
I64vec1 operator>>(int count) { return _m_psrlqi(vec, count); } |
126 |
|
I64vec1& operator>>=(const M64 &a) { return *this = (I64vec1) _m_psrlq(vec, a); } |
127 |
|
I64vec1& operator>>=(int count) { return *this = (I64vec1) _m_psrlqi(vec, count); } |
128 |
|
}; |
129 |
|
|
130 |
|
/* I32vec2 Class: |
131 |
|
* 2 elements, each element either a signed or unsigned int |
132 |
|
*/ |
133 |
|
class I32vec2 : public M64 |
134 |
|
{ |
135 |
|
public: |
136 |
|
I32vec2() { } |
137 |
|
I32vec2(__m64 mm) : M64(mm) { } |
138 |
|
EXPLICIT I32vec2(int i) : M64 (i) { } |
139 |
|
EXPLICIT I32vec2(__int64 i): M64(i) {} |
140 |
|
|
141 |
|
/* Assignment Operator */ |
142 |
|
I32vec2& operator= (const M64 &a) { return *this = (I32vec2) a; } |
143 |
|
|
144 |
|
/* Logical Assignment Operators */ |
145 |
|
I32vec2& operator&=(const M64 &a) { return *this = (I32vec2) _m_pand(vec,a); } |
146 |
|
I32vec2& operator|=(const M64 &a) { return *this = (I32vec2) _m_por(vec,a); } |
147 |
|
I32vec2& operator^=(const M64 &a) { return *this = (I32vec2) _m_pxor(vec,a); } |
148 |
|
|
149 |
|
/* Addition & Subtraction Assignment Operators */ |
150 |
|
I32vec2& operator +=(const I32vec2 &a) { return *this = (I32vec2) _m_paddd(vec,a); } |
151 |
|
I32vec2& operator -=(const I32vec2 &a) { return *this = (I32vec2) _m_psubd(vec,a); } |
152 |
|
|
153 |
|
/* Shift Logical Operators */ |
154 |
|
I32vec2 operator<<(const I32vec2 &a) { return _m_pslld(vec,a); } |
155 |
|
I32vec2 operator<<(int count) { return _m_pslldi(vec,count); } |
156 |
|
I32vec2& operator<<=(const I32vec2 &a) { return *this = (I32vec2) _m_pslld(vec,a); } |
157 |
|
I32vec2& operator<<=(int count) { return *this = (I32vec2) _m_pslldi(vec,count); } |
158 |
|
|
159 |
|
}; |
160 |
|
|
161 |
|
/* Compare For Equality */ |
162 |
|
inline I32vec2 cmpeq(const I32vec2 &a, const I32vec2 &b) { return _m_pcmpeqd(a,b); } |
163 |
|
inline I32vec2 cmpneq(const I32vec2 &a, const I32vec2 &b) { return _m_pandn(_m_pcmpeqd(a,b), M64(0xffffffffffffffffi64)); } |
164 |
|
/* Unpacks */ |
165 |
|
inline I32vec2 unpack_low(const I32vec2 &a, const I32vec2 &b) {return _m_punpckldq(a,b); } |
166 |
|
inline I32vec2 unpack_high(const I32vec2 &a, const I32vec2 &b) {return _m_punpckhdq(a,b); } |
167 |
|
|
168 |
|
/* Is32vec2 Class: |
169 |
|
* 2 elements, each element a signed int |
170 |
|
*/ |
171 |
|
class Is32vec2 : public I32vec2 |
172 |
|
{ |
173 |
|
public: |
174 |
|
Is32vec2() { } |
175 |
|
Is32vec2(__m64 mm) : I32vec2(mm) { } |
176 |
|
Is32vec2(signed int i0, signed int i1) |
177 |
|
{ |
178 |
|
_MM_2DW(0,vec) = i1; |
179 |
|
_MM_2DW(1,vec) = i0; |
180 |
|
} |
181 |
|
EXPLICIT Is32vec2(int i) : I32vec2 (i) {} |
182 |
|
EXPLICIT Is32vec2(__int64 i): I32vec2(i) {} |
183 |
|
|
184 |
|
/* Assignment Operator */ |
185 |
|
Is32vec2& operator= (const M64 &a) { return *this = (Is32vec2) a; } |
186 |
|
|
187 |
|
/* Logical Assignment Operators */ |
188 |
|
Is32vec2& operator&=(const M64 &a) { return *this = (Is32vec2) _m_pand(vec,a); } |
189 |
|
Is32vec2& operator|=(const M64 &a) { return *this = (Is32vec2) _m_por(vec,a); } |
190 |
|
Is32vec2& operator^=(const M64 &a) { return *this = (Is32vec2) _m_pxor(vec,a); } |
191 |
|
|
192 |
|
/* Addition & Subtraction Assignment Operators */ |
193 |
|
Is32vec2& operator +=(const I32vec2 &a) { return *this = (Is32vec2) _m_paddd(vec,a); } |
194 |
|
Is32vec2& operator -=(const I32vec2 &a) { return *this = (Is32vec2) _m_psubd(vec,a); } |
195 |
|
|
196 |
|
/* Shift Logical Operators */ |
197 |
|
Is32vec2 operator<<(const M64 &a) { return _m_pslld(vec,a); } |
198 |
|
Is32vec2 operator<<(int count) { return _m_pslldi(vec,count); } |
199 |
|
Is32vec2& operator<<=(const M64 &a) { return *this = (Is32vec2) _m_pslld(vec,a); } |
200 |
|
Is32vec2& operator<<=(int count) { return *this = (Is32vec2) _m_pslldi(vec,count); } |
201 |
|
/* Shift Arithmetic Operations */ |
202 |
|
Is32vec2 operator>>(const M64 &a) { return _m_psrad(vec, a); } |
203 |
|
Is32vec2 operator>>(int count) { return _m_psradi(vec, count); } |
204 |
|
Is32vec2& operator>>=(const M64 &a) { return *this = (Is32vec2) _m_psrad(vec, a); } |
205 |
|
Is32vec2& operator>>=(int count) { return *this = (Is32vec2) _m_psradi(vec, count); } |
206 |
|
|
207 |
|
#if defined(_ENABLE_VEC_DEBUG) |
208 |
|
/* Output for Debug */ |
209 |
|
friend std::ostream& operator<< (std::ostream &os, const Is32vec2 &a) |
210 |
|
{ |
211 |
|
os << " [1]:" << _MM_2DW(1,a) |
212 |
|
<< " [0]:" << _MM_2DW(0,a); |
213 |
|
return os; |
214 |
|
} |
215 |
|
#endif |
216 |
|
|
217 |
|
/* Element Access for Debug, No data modified */ |
218 |
|
const int& operator[](int i)const |
219 |
|
{ |
220 |
|
assert(static_cast<unsigned int>(i) < 2); /* Only 2 elements to access */ |
221 |
|
return _MM_2DW(i,vec); |
222 |
|
} |
223 |
|
|
224 |
|
/* Element Access and Assignment for Debug */ |
225 |
|
int& operator[](int i) |
226 |
|
{ |
227 |
|
assert(static_cast<unsigned int>(i) < 2); /* Only 2 elements to access */ |
228 |
|
return _MM_2DW(i,vec); |
229 |
|
} |
230 |
|
}; |
231 |
|
|
232 |
|
/* Compares */ |
233 |
|
inline Is32vec2 cmpeq(const Is32vec2 &a, const Is32vec2 &b) { return _m_pcmpeqd(a,b); } |
234 |
|
inline Is32vec2 cmpneq(const Is32vec2 &a, const Is32vec2 &b) { return _m_pandn(_m_pcmpeqd(a,b), M64(0xffffffffffffffffi64)); } |
235 |
|
inline Is32vec2 cmpgt(const Is32vec2 &a, const Is32vec2 &b) { return _m_pcmpgtd(a,b); } |
236 |
|
inline Is32vec2 cmplt(const Is32vec2 &a, const Is32vec2 &b) { return _m_pcmpgtd(b,a); } |
237 |
|
inline Is32vec2 cmple(const Is32vec2 &a, const Is32vec2 &b) { return _m_pandn(_m_pcmpgtd(a,b), M64(0xffffffffffffffffi64)); } |
238 |
|
inline Is32vec2 cmpge(const Is32vec2 &a, const Is32vec2 &b) { return _m_pandn(_m_pcmpgtd(b,a), M64(0xffffffffffffffffi64)); } |
239 |
|
/* Unpacks & Pack */ |
240 |
|
inline Is32vec2 unpack_low(const Is32vec2 &a, const Is32vec2 &b) { return _m_punpckldq(a,b); } |
241 |
|
inline Is32vec2 unpack_high(const Is32vec2 &a, const Is32vec2 &b) { return _m_punpckhdq(a,b); } |
242 |
|
|
243 |
|
/* Iu32vec2 Class: |
244 |
|
* 2 elements, each element unsigned int |
245 |
|
*/ |
246 |
|
class Iu32vec2 : public I32vec2 |
247 |
|
{ |
248 |
|
public: |
249 |
|
Iu32vec2() { } |
250 |
|
Iu32vec2(__m64 mm) : I32vec2(mm) { } |
251 |
|
Iu32vec2(unsigned int ui0, unsigned int ui1) |
252 |
|
{ |
253 |
|
_MM_2UDW(0,vec) = ui1; |
254 |
|
_MM_2UDW(1,vec) = ui0; |
255 |
|
} |
256 |
|
|
257 |
|
EXPLICIT Iu32vec2(int i) : I32vec2 (i) { } |
258 |
|
EXPLICIT Iu32vec2(__int64 i) : I32vec2 (i) { } |
259 |
|
|
260 |
|
/* Assignment Operator */ |
261 |
|
Iu32vec2& operator= (const M64 &a) { return *this = (Iu32vec2) a; } |
262 |
|
|
263 |
|
/* Logical Assignment Operators */ |
264 |
|
Iu32vec2& operator&=(const M64 &a) { return *this = (Iu32vec2) _m_pand(vec,a); } |
265 |
|
Iu32vec2& operator|=(const M64 &a) { return *this = (Iu32vec2) _m_por(vec,a); } |
266 |
|
Iu32vec2& operator^=(const M64 &a) { return *this = (Iu32vec2) _m_pxor(vec,a); } |
267 |
|
|
268 |
|
/* Addition & Subtraction Assignment Operators */ |
269 |
|
Iu32vec2& operator +=(const I32vec2 &a) { return *this = (Iu32vec2) _m_paddd(vec,a); } |
270 |
|
Iu32vec2& operator -=(const I32vec2 &a) { return *this = (Iu32vec2) _m_psubd(vec,a); } |
271 |
|
|
272 |
|
/* Shift Logical Operators */ |
273 |
|
Iu32vec2 operator<<(const M64 &a) { return _m_pslld(vec,a); } |
274 |
|
Iu32vec2 operator<<(int count) { return _m_pslldi(vec,count); } |
275 |
|
Iu32vec2& operator<<=(const M64 &a) { return *this = (Iu32vec2) _m_pslld(vec,a); } |
276 |
|
Iu32vec2& operator<<=(int count) { return *this = (Iu32vec2) _m_pslldi(vec,count); } |
277 |
|
Iu32vec2 operator>>(const M64 &a) { return _m_psrld(vec,a); } |
278 |
|
Iu32vec2 operator>>(int count) { return _m_psrldi(vec,count); } |
279 |
|
Iu32vec2& operator>>=(const M64 &a) { return *this = (Iu32vec2) _m_psrld(vec,a); } |
280 |
|
Iu32vec2& operator>>=(int count) { return *this = (Iu32vec2) _m_psrldi(vec,count); } |
281 |
|
|
282 |
|
#if defined(_ENABLE_VEC_DEBUG) |
283 |
|
/* Output for Debug */ |
284 |
|
friend std::ostream& operator<< (std::ostream &os, const Iu32vec2 &a) |
285 |
|
{ |
286 |
|
os << " [1]:" << _MM_2UDW(1,a) |
287 |
|
<< " [0]:" << _MM_2UDW(0,a); |
288 |
|
return os; |
289 |
|
} |
290 |
|
#endif |
291 |
|
|
292 |
|
/* Element Access for Debug, No data modified */ |
293 |
|
const unsigned int& operator[](int i)const |
294 |
|
{ |
295 |
|
assert(static_cast<unsigned int>(i) < 2); /* Only 2 elements to access */ |
296 |
|
return _MM_2UDW(i,vec); |
297 |
|
} |
298 |
|
|
299 |
|
/* Element Access and Assignment for Debug */ |
300 |
|
unsigned int& operator[](int i) |
301 |
|
{ |
302 |
|
assert(static_cast<unsigned int>(i) < 2); /* Only 2 elements to access */ |
303 |
|
return _MM_2UDW(i,vec); |
304 |
|
} |
305 |
|
}; |
306 |
|
|
307 |
|
/* Compares For Equality / Inequality */ |
308 |
|
inline Iu32vec2 cmpeq(const Iu32vec2 &a, const Iu32vec2 &b) { return _m_pcmpeqd(a,b); } |
309 |
|
inline Iu32vec2 cmpneq(const Iu32vec2 &a, const Iu32vec2 &b) { return _m_pandn(_m_pcmpeqd(a,b), M64(0xffffffffffffffffi64)); } |
310 |
|
/* Unpacks */ |
311 |
|
inline Iu32vec2 unpack_low(const Iu32vec2 &a, const Iu32vec2 &b) {return _m_punpckldq(a,b); } |
312 |
|
inline Iu32vec2 unpack_high(const Iu32vec2 &a, const Iu32vec2 &b) {return _m_punpckhdq(a,b); } |
313 |
|
|
314 |
|
/* I16vec4 Class: |
315 |
|
* 4 elements, each element either a signed or unsigned short |
316 |
|
*/ |
317 |
|
class I16vec4 : public M64 |
318 |
|
{ |
319 |
|
public: |
320 |
|
I16vec4() { } |
321 |
|
I16vec4(__m64 mm) : M64(mm) { } |
322 |
|
EXPLICIT I16vec4(__int64 i) : M64 (i) { } |
323 |
|
EXPLICIT I16vec4(int i) : M64 (i) { } |
324 |
|
|
325 |
|
/* Assignment Operator */ |
326 |
|
I16vec4& operator= (const M64 &a) { return *this = (I16vec4) a; } |
327 |
|
|
328 |
|
/* Addition & Subtraction Assignment Operators */ |
329 |
|
I16vec4& operator&=(const M64 &a) { return *this = (I16vec4) _m_pand(vec,a); } |
330 |
|
I16vec4& operator|=(const M64 &a) { return *this = (I16vec4) _m_por(vec,a); } |
331 |
|
I16vec4& operator^=(const M64 &a) { return *this = (I16vec4) _m_pxor(vec,a); } |
332 |
|
|
333 |
|
/* Addition & Subtraction Assignment Operators */ |
334 |
|
I16vec4& operator +=(const I16vec4 &a) { return *this = (I16vec4)_m_paddw(vec,a); } |
335 |
|
I16vec4& operator -=(const I16vec4 &a) { return *this = (I16vec4)_m_psubw(vec,a); } |
336 |
|
I16vec4& operator *=(const I16vec4 &a) { return *this = (I16vec4)_m_pmullw(vec,a); } |
337 |
|
|
338 |
|
/* Shift Logical Operators */ |
339 |
|
I16vec4 operator<<(const I16vec4 &a) { return _m_psllw(vec,a); } |
340 |
|
I16vec4 operator<<(int count) { return _m_psllwi(vec,count); } |
341 |
|
I16vec4& operator<<=(const I16vec4 &a) { return *this = (I16vec4)_m_psllw(vec,a); } |
342 |
|
I16vec4& operator<<=(int count) { return *this = (I16vec4)_m_psllwi(vec,count); } |
343 |
|
}; |
344 |
|
|
345 |
|
inline I16vec4 operator*(const I16vec4 &a, const I16vec4 &b) { return _m_pmullw(a,b); } |
346 |
|
inline I16vec4 cmpeq(const I16vec4 &a, const I16vec4 &b) { return _m_pcmpeqw(a,b); } |
347 |
|
inline I16vec4 cmpneq(const I16vec4 &a, const I16vec4 &b) { return _m_pandn(_m_pcmpeqw(a,b), M64(0xffffffffffffffffi64)); } |
348 |
|
|
349 |
|
inline I16vec4 unpack_low(const I16vec4 &a, const I16vec4 &b) { return _m_punpcklwd(a,b); } |
350 |
|
inline I16vec4 unpack_high(const I16vec4 &a, const I16vec4 &b) { return _m_punpckhwd(a,b); } |
351 |
|
|
352 |
|
/* Is16vec4 Class: |
353 |
|
* 4 elements, each element signed short |
354 |
|
*/ |
355 |
|
class Is16vec4 : public I16vec4 |
356 |
|
{ |
357 |
|
public: |
358 |
|
Is16vec4() { } |
359 |
|
Is16vec4(__m64 mm) : I16vec4(mm) { } |
360 |
|
Is16vec4(short i0, short i1, short i2, short i3) |
361 |
|
{ |
362 |
|
_MM_4W(0,vec) = i3; |
363 |
|
_MM_4W(1,vec) = i2; |
364 |
|
_MM_4W(2,vec) = i1; |
365 |
|
_MM_4W(3,vec) = i0; |
366 |
|
} |
367 |
|
|
368 |
|
EXPLICIT Is16vec4(__int64 i) : I16vec4 (i) { } |
369 |
|
EXPLICIT Is16vec4(int i) : I16vec4 (i) { } |
370 |
|
|
371 |
|
/* Assignment Operator */ |
372 |
|
Is16vec4& operator= (const M64 &a) { return *this = (Is16vec4) a; } |
373 |
|
|
374 |
|
/* Addition & Subtraction Assignment Operators */ |
375 |
|
Is16vec4& operator&=(const M64 &a) { return *this = (Is16vec4) _m_pand(vec,a); } |
376 |
|
Is16vec4& operator|=(const M64 &a) { return *this = (Is16vec4) _m_por(vec,a); } |
377 |
|
Is16vec4& operator^=(const M64 &a) { return *this = (Is16vec4) _m_pxor(vec,a); } |
378 |
|
|
379 |
|
/* Addition & Subtraction Assignment Operators */ |
380 |
|
Is16vec4& operator +=(const I16vec4 &a) { return *this = (Is16vec4)_m_paddw(vec,a); } |
381 |
|
Is16vec4& operator -=(const I16vec4 &a) { return *this = (Is16vec4)_m_psubw(vec,a); } |
382 |
|
Is16vec4& operator *=(const I16vec4 &a) { return *this = (Is16vec4)_m_pmullw(vec,a); } |
383 |
|
|
384 |
|
/* Shift Logical Operators */ |
385 |
|
Is16vec4 operator<<(const M64 &a) { return _m_psllw(vec,a); } |
386 |
|
Is16vec4 operator<<(int count) { return _m_psllwi(vec,count); } |
387 |
|
Is16vec4& operator<<=(const M64 &a) { return *this = (Is16vec4)_m_psllw(vec,a); } |
388 |
|
Is16vec4& operator<<=(int count) { return *this = (Is16vec4)_m_psllwi(vec,count); } |
389 |
|
/* Shift Arithmetic Operations */ |
390 |
|
Is16vec4 operator>>(const M64 &a) { return _m_psraw(vec,a); } |
391 |
|
Is16vec4 operator>>(int count) { return _m_psrawi(vec,count); } |
392 |
|
Is16vec4& operator>>=(const M64 &a) { return *this = (Is16vec4) _m_psraw(vec,a); } |
393 |
|
Is16vec4& operator>>=(int count) { return *this = (Is16vec4) _m_psrawi(vec,count); } |
394 |
|
|
395 |
|
#if defined(_ENABLE_VEC_DEBUG) |
396 |
|
/* Output for Debug */ |
397 |
|
friend std::ostream& operator<< (std::ostream &os, const Is16vec4 &a) |
398 |
|
{ |
399 |
|
os << "[3]:" << _MM_4W(3,a) |
400 |
|
<< " [2]:" << _MM_4W(2,a) |
401 |
|
<< " [1]:" << _MM_4W(1,a) |
402 |
|
<< " [0]:" << _MM_4W(0,a); |
403 |
|
return os; |
404 |
|
} |
405 |
|
#endif |
406 |
|
|
407 |
|
/* Element Access for Debug, No data modified */ |
408 |
|
const short& operator[](int i)const |
409 |
|
{ |
410 |
|
assert(static_cast<unsigned int>(i) < 4); /* Only 4 elements to access */ |
411 |
|
return _MM_4W(i,vec); |
412 |
|
} |
413 |
|
|
414 |
|
/* Element Access for Debug */ |
415 |
|
short& operator[](int i) |
416 |
|
{ |
417 |
|
assert(static_cast<unsigned int>(i) < 4); /* Only 4 elements to access */ |
418 |
|
return _MM_4W(i,vec); |
419 |
|
} |
420 |
|
}; |
421 |
|
|
422 |
|
inline Is16vec4 operator*(const Is16vec4 &a, const Is16vec4 &b) { return _m_pmullw(a,b); } |
423 |
|
|
424 |
|
/* Compares */ |
425 |
|
inline Is16vec4 cmpeq(const Is16vec4 &a, const Is16vec4 &b) { return _m_pcmpeqw(a,b); } |
426 |
|
inline Is16vec4 cmpneq(const Is16vec4 &a, const Is16vec4 &b) { return _m_pandn(_m_pcmpeqw(a,b), M64(0xffffffffffffffffi64)); } |
427 |
|
inline Is16vec4 cmpgt(const Is16vec4 &a, const Is16vec4 &b) { return _m_pcmpgtw(a,b); } |
428 |
|
inline Is16vec4 cmplt(const Is16vec4 &a, const Is16vec4 &b) { return _m_pcmpgtw(b,a); } |
429 |
|
inline Is16vec4 cmple(const Is16vec4 &a, const Is16vec4 &b) { return _m_pandn(_m_pcmpgtw(a,b), M64(0xffffffffffffffffi64)); } |
430 |
|
inline Is16vec4 cmpge(const Is16vec4 &a, const Is16vec4 &b) { return _m_pandn(_m_pcmpgtw(b,a), M64(0xffffffffffffffffi64)); } |
431 |
|
/* Unpacks */ |
432 |
|
inline Is16vec4 unpack_low(const Is16vec4 &a, const Is16vec4 &b) { return _m_punpcklwd(a,b); } |
433 |
|
inline Is16vec4 unpack_high(const Is16vec4 &a, const Is16vec4 &b) { return _m_punpckhwd(a,b); } |
434 |
|
|
435 |
|
inline Is16vec4 sat_add(const Is16vec4 &a, const Is16vec4 &b) { return _m_paddsw(a,b); } |
436 |
|
inline Is16vec4 sat_sub(const Is16vec4 &a, const Is16vec4 &b) { return _m_psubsw(a,b); } |
437 |
|
inline Is16vec4 mul_high(const Is16vec4 &a, const Is16vec4 &b) { return _m_pmulhw(a,b); } |
438 |
|
inline Is32vec2 mul_add(const Is16vec4 &a, const Is16vec4 &b) { return _m_pmaddwd(a,b);} |
439 |
|
|
440 |
|
|
441 |
|
/* Iu16vec4 Class: |
442 |
|
* 4 elements, each element unsigned short |
443 |
|
*/ |
444 |
|
class Iu16vec4 : public I16vec4 |
445 |
|
{ |
446 |
|
public: |
447 |
|
Iu16vec4() { } |
448 |
|
Iu16vec4(__m64 mm) : I16vec4(mm) { } |
449 |
|
Iu16vec4(unsigned short ui0, unsigned short ui1, unsigned short ui2, unsigned short ui3) |
450 |
|
{ |
451 |
|
_MM_4UW(0,vec) = ui3; |
452 |
|
_MM_4UW(1,vec) = ui2; |
453 |
|
_MM_4UW(2,vec) = ui1; |
454 |
|
_MM_4UW(3,vec) = ui0; |
455 |
|
} |
456 |
|
EXPLICIT Iu16vec4(__int64 i) : I16vec4 (i) { } |
457 |
|
EXPLICIT Iu16vec4(int i) : I16vec4 (i) { } |
458 |
|
|
459 |
|
/* Assignment Operator */ |
460 |
|
Iu16vec4& operator= (const M64 &a) { return *this = (Iu16vec4) a; } |
461 |
|
|
462 |
|
/* Logical Assignment Operators */ |
463 |
|
Iu16vec4& operator&=(const M64 &a) { return *this = (Iu16vec4) _m_pand(vec,a); } |
464 |
|
Iu16vec4& operator|=(const M64 &a) { return *this = (Iu16vec4) _m_por(vec,a); } |
465 |
|
Iu16vec4& operator^=(const M64 &a) { return *this = (Iu16vec4) _m_pxor(vec,a); } |
466 |
|
|
467 |
|
/* Addition & Subtraction Assignment Operators */ |
468 |
|
Iu16vec4& operator +=(const I16vec4 &a) { return *this = (Iu16vec4)_m_paddw(vec,a); } |
469 |
|
Iu16vec4& operator -=(const I16vec4 &a) { return *this = (Iu16vec4)_m_psubw(vec,a); } |
470 |
|
Iu16vec4& operator *=(const I16vec4 &a) { return *this = (Iu16vec4)_m_pmullw(vec,a); } |
471 |
|
|
472 |
|
/* Shift Logical Operators */ |
473 |
|
Iu16vec4 operator<<(const M64 &a) { return _m_psllw(vec,a); } |
474 |
|
Iu16vec4 operator<<(int count) { return _m_psllwi(vec,count); } |
475 |
|
Iu16vec4& operator<<=(const M64 &a) { return *this = (Iu16vec4)_m_psllw(vec,a); } |
476 |
|
Iu16vec4& operator<<=(int count) { return *this = (Iu16vec4)_m_psllwi(vec,count); } |
477 |
|
Iu16vec4 operator>>(const M64 &a) { return _m_psrlw(vec,a); } |
478 |
|
Iu16vec4 operator>>(int count) { return _m_psrlwi(vec,count); } |
479 |
|
Iu16vec4& operator>>=(const M64 &a) { return *this = (Iu16vec4) _m_psrlw(vec,a); } |
480 |
|
Iu16vec4& operator>>=(int count) { return *this = (Iu16vec4) _m_psrlwi(vec,count); } |
481 |
|
|
482 |
|
#if defined(_ENABLE_VEC_DEBUG) |
483 |
|
/* Output for Debug */ |
484 |
|
friend std::ostream& operator<< (std::ostream &os, const Iu16vec4 &a) |
485 |
|
{ |
486 |
|
os << "[3]:" << _MM_4UW(3,a) |
487 |
|
<< " [2]:" << _MM_4UW(2,a) |
488 |
|
<< " [1]:" << _MM_4UW(1,a) |
489 |
|
<< " [0]:" << _MM_4UW(0,a); |
490 |
|
return os; |
491 |
|
} |
492 |
|
#endif |
493 |
|
|
494 |
|
/* Element Access for Debug, No data modified */ |
495 |
|
const unsigned short& operator[](int i)const |
496 |
|
{ |
497 |
|
assert(static_cast<unsigned int>(i) < 4); /* Only 4 elements to access */ |
498 |
|
return _MM_4UW(i,vec); |
499 |
|
} |
500 |
|
|
501 |
|
/* Element Access and Assignment for Debug */ |
502 |
|
unsigned short& operator[](int i) |
503 |
|
{ |
504 |
|
assert(static_cast<unsigned int>(i) < 4); /* Only 4 elements to access */ |
505 |
|
return _MM_4UW(i,vec); |
506 |
|
} |
507 |
|
}; |
508 |
|
|
509 |
|
inline Iu16vec4 operator*(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_pmullw(a,b); } |
510 |
|
inline Iu16vec4 cmpeq(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_pcmpeqw(a,b); } |
511 |
|
inline Iu16vec4 cmpneq(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_pandn(_m_pcmpeqw(a,b), M64(0xffffffffffffffffi64)); } |
512 |
|
|
513 |
|
inline Iu16vec4 sat_add(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_paddusw(a,b); } |
514 |
|
inline Iu16vec4 sat_sub(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_psubusw(a,b); } |
515 |
|
|
516 |
|
inline Iu16vec4 unpack_low(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_punpcklwd(a,b); } |
517 |
|
inline Iu16vec4 unpack_high(const Iu16vec4 &a, const Iu16vec4 &b) { return _m_punpckhwd(a,b); } |
518 |
|
|
519 |
|
/* I8vec8 Class: |
520 |
|
* 8 elements, each element either unsigned or signed char |
521 |
|
*/ |
522 |
|
class I8vec8 : public M64 |
523 |
|
{ |
524 |
|
public: |
525 |
|
I8vec8() { } |
526 |
|
I8vec8(__m64 mm) : M64(mm) { } |
527 |
|
EXPLICIT I8vec8(__int64 i) : M64 (i) { } |
528 |
|
EXPLICIT I8vec8(int i) : M64 (i) { } |
529 |
|
|
530 |
|
/* Assignment Operator */ |
531 |
|
I8vec8& operator= (const M64 &a) { return *this = (I8vec8) a; } |
532 |
|
|
533 |
|
/* Logical Assignment Operators */ |
534 |
|
I8vec8& operator&=(const M64 &a) { return *this = (I8vec8) _m_pand(vec,a); } |
535 |
|
I8vec8& operator|=(const M64 &a) { return *this = (I8vec8) _m_por(vec,a); } |
536 |
|
I8vec8& operator^=(const M64 &a) { return *this = (I8vec8) _m_pxor(vec,a); } |
537 |
|
|
538 |
|
/* Addition & Subtraction Assignment Operators */ |
539 |
|
I8vec8& operator +=(const I8vec8 &a) { return *this = (I8vec8) _m_paddb(vec,a); } |
540 |
|
I8vec8& operator -=(const I8vec8 &a) { return *this = (I8vec8) _m_psubb(vec,a); } |
541 |
|
}; |
542 |
|
|
543 |
|
|
544 |
|
inline I8vec8 cmpeq(const I8vec8 &a, const I8vec8 &b) { return _m_pcmpeqb(a,b); } |
545 |
|
inline I8vec8 cmpneq(const I8vec8 &a, const I8vec8 &b) { return _m_pandn(_m_pcmpeqb(a,b), M64(0xffffffffffffffffi64)); } |
546 |
|
|
547 |
|
inline I8vec8 unpack_low(const I8vec8 &a, const I8vec8 &b) { return _m_punpcklbw(a,b); } |
548 |
|
inline I8vec8 unpack_high(const I8vec8 &a, const I8vec8 &b) { return _m_punpckhbw(a,b); } |
549 |
|
|
550 |
|
/* Is8vec8 Class: |
551 |
|
* 8 elements, each element signed char |
552 |
|
*/ |
553 |
|
class Is8vec8 : public I8vec8 |
554 |
|
{ |
555 |
|
public: |
556 |
|
Is8vec8() { } |
557 |
|
Is8vec8(__m64 mm) : I8vec8(mm) { } |
558 |
|
Is8vec8(signed char s0,signed char s1,signed char s2,signed char s3,signed char s4,signed char s5,signed char s6,signed char s7) |
559 |
|
{ |
560 |
|
_MM_8B(0,vec) = s7; |
561 |
|
_MM_8B(1,vec) = s6; |
562 |
|
_MM_8B(2,vec) = s5; |
563 |
|
_MM_8B(3,vec) = s4; |
564 |
|
_MM_8B(4,vec) = s3; |
565 |
|
_MM_8B(5,vec) = s2; |
566 |
|
_MM_8B(6,vec) = s1; |
567 |
|
_MM_8B(7,vec) = s0; |
568 |
|
} |
569 |
|
|
570 |
|
EXPLICIT Is8vec8(__int64 i) : I8vec8 (i) { } |
571 |
|
EXPLICIT Is8vec8(int i) : I8vec8 (i) { } |
572 |
|
|
573 |
|
/* Assignment Operator */ |
574 |
|
Is8vec8& operator= (const M64 &a) { return *this = (Is8vec8) a; } |
575 |
|
|
576 |
|
/* Logical Assignment Operators */ |
577 |
|
Is8vec8& operator&=(const M64 &a) { return *this = (Is8vec8) _m_pand(vec,a); } |
578 |
|
Is8vec8& operator|=(const M64 &a) { return *this = (Is8vec8) _m_por(vec,a); } |
579 |
|
Is8vec8& operator^=(const M64 &a) { return *this = (Is8vec8) _m_pxor(vec,a); } |
580 |
|
|
581 |
|
/* Addition & Subtraction Assignment Operators */ |
582 |
|
Is8vec8& operator +=(const I8vec8 &a) { return *this = (Is8vec8) _m_paddb(vec,a); } |
583 |
|
Is8vec8& operator -=(const I8vec8 &a) { return *this = (Is8vec8) _m_psubb(vec,a); } |
584 |
|
|
585 |
|
#if defined(_ENABLE_VEC_DEBUG) |
586 |
|
/* Output for Debug */ |
587 |
|
friend std::ostream& operator<< (std::ostream &os, const Is8vec8 &a) |
588 |
|
{ |
589 |
|
os << "[7]:" << short(_MM_8B(7,a)) |
590 |
|
<< " [6]:" << short(_MM_8B(6,a)) |
591 |
|
<< " [5]:" << short(_MM_8B(5,a)) |
592 |
|
<< " [4]:" << short(_MM_8B(4,a)) |
593 |
|
<< " [3]:" << short(_MM_8B(3,a)) |
594 |
|
<< " [2]:" << short(_MM_8B(2,a)) |
595 |
|
<< " [1]:" << short(_MM_8B(1,a)) |
596 |
|
<< " [0]:" << short(_MM_8B(0,a)); |
597 |
|
return os; |
598 |
|
} |
599 |
|
#endif |
600 |
|
|
601 |
|
/* Element Access for Debug, No data modified */ |
602 |
|
const signed char& operator[](int i)const |
603 |
|
{ |
604 |
|
assert(static_cast<unsigned int>(i) < 8); /* Only 8 elements to access */ |
605 |
|
return _MM_8B(i,vec); |
606 |
|
} |
607 |
|
|
608 |
|
/* Element Access and Assignment for Debug */ |
609 |
|
signed char& operator[](int i) |
610 |
|
{ |
611 |
|
assert(static_cast<unsigned int>(i) < 8); /* Only 8 elements to access */ |
612 |
|
return _MM_8B(i,vec); |
613 |
|
} |
614 |
|
}; |
615 |
|
|
616 |
|
/* Additional Is8vec8 functions: compares, unpacks, sat add/sub */ |
617 |
|
inline Is8vec8 cmpeq(const Is8vec8 &a, const Is8vec8 &b) { return _m_pcmpeqb(a,b); } |
618 |
|
inline Is8vec8 cmpneq(const Is8vec8 &a, const Is8vec8 &b) { return _m_pandn(_m_pcmpeqb(a,b), M64(0xffffffffffffffffi64)); } |
619 |
|
inline Is8vec8 cmpgt(const Is8vec8 &a, const Is8vec8 &b) { return _m_pcmpgtb(a,b); } |
620 |
|
inline Is8vec8 cmplt(const Is8vec8 &a, const Is8vec8 &b) { return _m_pcmpgtb(b,a); } |
621 |
|
inline Is8vec8 cmple(const Is8vec8 &a, const Is8vec8 &b) { return _m_pandn(_m_pcmpgtb(a,b), M64(0xffffffffffffffffi64)); } |
622 |
|
inline Is8vec8 cmpge(const Is8vec8 &a, const Is8vec8 &b) { return _m_pandn(_m_pcmpgtb(b,a), M64(0xffffffffffffffffi64)); } |
623 |
|
|
624 |
|
inline Is8vec8 unpack_low(const Is8vec8 &a, const Is8vec8 &b) { return _m_punpcklbw(a,b); } |
625 |
|
inline Is8vec8 unpack_high(const Is8vec8 &a, const Is8vec8 &b) { return _m_punpckhbw(a,b); } |
626 |
|
|
627 |
|
inline Is8vec8 sat_add(const Is8vec8 &a, const Is8vec8 &b) { return _m_paddsb(a,b); } |
628 |
|
inline Is8vec8 sat_sub(const Is8vec8 &a, const Is8vec8 &b) { return _m_psubsb(a,b); } |
629 |
|
|
630 |
|
/* Iu8vec8 Class: |
631 |
|
* 8 elements, each element unsigned char |
632 |
|
*/ |
633 |
|
class Iu8vec8 : public I8vec8 |
634 |
|
{ |
635 |
|
public: |
636 |
|
Iu8vec8() { } |
637 |
|
Iu8vec8(__m64 mm) : I8vec8(mm) { } |
638 |
|
Iu8vec8(unsigned char s0,unsigned char s1,unsigned char s2,unsigned char s3,unsigned char s4,unsigned char s5,unsigned char s6,unsigned char s7) |
639 |
|
{ |
640 |
|
_MM_8UB(0,vec) = s7; |
641 |
|
_MM_8UB(1,vec) = s6; |
642 |
|
_MM_8UB(2,vec) = s5; |
643 |
|
_MM_8UB(3,vec) = s4; |
644 |
|
_MM_8UB(4,vec) = s3; |
645 |
|
_MM_8UB(5,vec) = s2; |
646 |
|
_MM_8UB(6,vec) = s1; |
647 |
|
_MM_8UB(7,vec) = s0; |
648 |
|
} |
649 |
|
EXPLICIT Iu8vec8(__int64 i) : I8vec8 (i) { } |
650 |
|
EXPLICIT Iu8vec8(int i) : I8vec8 (i) { } |
651 |
|
|
652 |
|
/* Assignment Operator */ |
653 |
|
Iu8vec8& operator= (const M64 &a) { return *this = (Iu8vec8) a; } |
654 |
|
/* Logical Assignment Operators */ |
655 |
|
Iu8vec8& operator&=(const M64 &a) { return *this = (Iu8vec8) _m_pand(vec,a); } |
656 |
|
Iu8vec8& operator|=(const M64 &a) { return *this = (Iu8vec8) _m_por(vec,a); } |
657 |
|
Iu8vec8& operator^=(const M64 &a) { return *this = (Iu8vec8) _m_pxor(vec,a); } |
658 |
|
/* Addition & Subtraction Assignment Operators */ |
659 |
|
Iu8vec8& operator +=(const I8vec8 &a) { return *this = (Iu8vec8) _m_paddb(vec,a); } |
660 |
|
Iu8vec8& operator -=(const I8vec8 &a) { return *this = (Iu8vec8) _m_psubb(vec,a); } |
661 |
|
|
662 |
|
#if defined(_ENABLE_VEC_DEBUG) |
663 |
|
/* Output for Debug */ |
664 |
|
friend std::ostream& operator << (std::ostream &os, const Iu8vec8 &a) |
665 |
|
{ |
666 |
|
os << "[7]:" << unsigned short(_MM_8UB(7,a)) |
667 |
|
<< " [6]:" << unsigned short(_MM_8UB(6,a)) |
668 |
|
<< " [5]:" << unsigned short(_MM_8UB(5,a)) |
669 |
|
<< " [4]:" << unsigned short(_MM_8UB(4,a)) |
670 |
|
<< " [3]:" << unsigned short(_MM_8UB(3,a)) |
671 |
|
<< " [2]:" << unsigned short(_MM_8UB(2,a)) |
672 |
|
<< " [1]:" << unsigned short(_MM_8UB(1,a)) |
673 |
|
<< " [0]:" << unsigned short(_MM_8UB(0,a)); |
674 |
|
return os; |
675 |
|
} |
676 |
|
#endif |
677 |
|
|
678 |
|
/* Element Access for Debug, No data modified */ |
679 |
|
const unsigned char& operator[](int i)const |
680 |
|
{ |
681 |
|
assert(static_cast<unsigned int>(i) < 8); /* Only 8 elements to access */ |
682 |
|
return _MM_8UB(i,vec); |
683 |
|
} |
684 |
|
|
685 |
|
/* Element Access for Debug */ |
686 |
|
unsigned char& operator[](int i) |
687 |
|
{ |
688 |
|
assert(static_cast<unsigned int>(i) < 8); /* Only 8 elements to access */ |
689 |
|
return _MM_8UB(i,vec); |
690 |
|
} |
691 |
|
}; |
692 |
|
|
693 |
|
/* Additional Iu8vec8 functions: cmpeq,cmpneq, unpacks, sat add/sub */ |
694 |
|
inline Iu8vec8 cmpeq(const Iu8vec8 &a, const Iu8vec8 &b) { return _m_pcmpeqb(a,b); } |
695 |
|
inline Iu8vec8 cmpneq(const Iu8vec8 &a, const Iu8vec8 &b) { return _m_pandn(_m_pcmpeqb(a,b), M64(0xffffffffffffffffi64)); } |
696 |
|
|
697 |
|
inline Iu8vec8 unpack_low(const Iu8vec8 &a, const Iu8vec8 &b) { return _m_punpcklbw(a,b); } |
698 |
|
inline Iu8vec8 unpack_high(const Iu8vec8 &a, const Iu8vec8 &b) { return _m_punpckhbw(a,b); } |
699 |
|
|
700 |
|
inline Iu8vec8 sat_add(const Iu8vec8 &a, const Iu8vec8 &b) { return _m_paddusb(a,b); } |
701 |
|
inline Iu8vec8 sat_sub(const Iu8vec8 &a, const Iu8vec8 &b) { return _m_psubusb(a,b); } |
702 |
|
|
703 |
|
inline Is16vec4 pack_sat(const Is32vec2 &a, const Is32vec2 &b) { return _m_packssdw(a,b); } |
704 |
|
inline Is8vec8 pack_sat(const Is16vec4 &a, const Is16vec4 &b) { return _m_packsswb(a,b); } |
705 |
|
inline Iu8vec8 packu_sat(const Is16vec4 &a, const Is16vec4 &b) { return _m_packuswb(a,b); } |
706 |
|
|
707 |
|
/********************************* Logicals ****************************************/ |
708 |
|
#define IVEC_LOGICALS(vect,element) \ |
709 |
|
inline I##vect##vec##element operator& (const I##vect##vec##element &a, const I##vect##vec##element &b) \ |
710 |
|
{ return _m_pand( a,b); } \ |
711 |
|
inline I##vect##vec##element operator| (const I##vect##vec##element &a, const I##vect##vec##element &b) \ |
712 |
|
{ return _m_por( a,b); } \ |
713 |
|
inline I##vect##vec##element operator^ (const I##vect##vec##element &a, const I##vect##vec##element &b) \ |
714 |
|
{ return _m_pxor( a,b); } \ |
715 |
|
inline I##vect##vec##element andnot (const I##vect##vec##element &a, const I##vect##vec##element &b) \ |
716 |
|
{ return _m_pandn( a,b); } |
717 |
|
|
718 |
|
IVEC_LOGICALS(8,8) |
719 |
|
IVEC_LOGICALS(u8,8) |
720 |
|
IVEC_LOGICALS(s8,8) |
721 |
|
IVEC_LOGICALS(16,4) |
722 |
|
IVEC_LOGICALS(u16,4) |
723 |
|
IVEC_LOGICALS(s16,4) |
724 |
|
IVEC_LOGICALS(32,2) |
725 |
|
IVEC_LOGICALS(u32,2) |
726 |
|
IVEC_LOGICALS(s32,2) |
727 |
|
IVEC_LOGICALS(64,1) |
728 |
|
#undef IVEC_LOGICALS |
729 |
|
|
730 |
|
/********************************* Add & Sub ****************************************/ |
731 |
|
#define IVEC_ADD_SUB(vect,element,opsize) \ |
732 |
|
inline I##vect##vec##element operator+ (const I##vect##vec##element &a, const I##vect##vec##element &b) \ |
733 |
|
{ return _m_padd##opsize( a,b); } \ |
734 |
|
inline I##vect##vec##element operator- (const I##vect##vec##element &a, const I##vect##vec##element &b) \ |
735 |
|
{ return _m_psub##opsize( a,b); } |
736 |
|
|
737 |
|
IVEC_ADD_SUB(8,8, b) |
738 |
|
IVEC_ADD_SUB(u8,8, b) |
739 |
|
IVEC_ADD_SUB(s8,8, b) |
750 |
|
* Where OP is one of the possible comparision operators. * |
751 |
|
* Example: r = select_eq(a,b,c,d); * |
752 |
|
* if "member at position x of the vector a" == "member at position x of vector b" * |
753 |
|
* assign the corresponding member in r from c, else assign from d. * |
754 |
|
********************************* Conditional Select ****************************************/ |
755 |
|
|
756 |
|
#define IVEC_SELECT(vect12,vect34,element,selop,arg1,arg2) \ |
757 |
|
inline I##vect34##vec##element select_##selop (const I##vect12##vec##element &a, const I##vect12##vec##element &b, const I##vect34##vec##element &c, const I##vect34##vec##element &d) \ |
758 |
|
{ \ |
759 |
|
I##vect12##vec##element mask = cmp##selop(a,b); \ |
760 |
|
return( I##vect34##vec##element ((mask & arg1 ) | I##vect12##vec##element ((_m_pandn(mask, arg2 ))))); \ |
761 |
|
} |
762 |
|
IVEC_SELECT(8,s8,8,eq,c,d) |
763 |
|
IVEC_SELECT(8,u8,8,eq,c,d) |
764 |
|
IVEC_SELECT(8,8,8,eq,c,d) |
765 |
|
IVEC_SELECT(8,s8,8,neq,c,d) |
766 |
|
IVEC_SELECT(8,u8,8,neq,c,d) |
767 |
|
IVEC_SELECT(8,8,8,neq,c,d) |
768 |
|
|
769 |
|
IVEC_SELECT(16,s16,4,eq,c,d) |
770 |
|
IVEC_SELECT(16,u16,4,eq,c,d) |
771 |
|
IVEC_SELECT(16,16,4,eq,c,d) |
772 |
|
IVEC_SELECT(16,s16,4,neq,c,d) |
773 |
|
IVEC_SELECT(16,u16,4,neq,c,d) |
774 |
|
IVEC_SELECT(16,16,4,neq,c,d) |
775 |
|
|
776 |
|
IVEC_SELECT(32,s32,2,eq,c,d) |
777 |
|
IVEC_SELECT(32,u32,2,eq,c,d) |
778 |
|
IVEC_SELECT(32,32,2,eq,c,d) |
779 |
|
IVEC_SELECT(32,s32,2,neq,c,d) |
780 |
|
IVEC_SELECT(32,u32,2,neq,c,d) |
781 |
|
IVEC_SELECT(32,32,2,neq,c,d) |
782 |
|
|
783 |
|
|
784 |
|
IVEC_SELECT(s8,s8,8,gt,c,d) |
785 |
|
IVEC_SELECT(s8,u8,8,gt,c,d) |
786 |
|
IVEC_SELECT(s8,8,8,gt,c,d) |
787 |
|
IVEC_SELECT(s8,s8,8,lt,c,d) |
788 |
|
IVEC_SELECT(s8,u8,8,lt,c,d) |
789 |
|
IVEC_SELECT(s8,8,8,lt,c,d) |
790 |
|
IVEC_SELECT(s8,s8,8,le,c,d) |
791 |
|
IVEC_SELECT(s8,u8,8,le,c,d) |
792 |
|
IVEC_SELECT(s8,8,8,le,c,d) |
793 |
|
IVEC_SELECT(s8,s8,8,ge,c,d) |
794 |
|
IVEC_SELECT(s8,u8,8,ge,c,d) |
795 |
|
IVEC_SELECT(s8,8,8,ge,c,d) |
796 |
|
|
797 |
|
IVEC_SELECT(s16,s16,4,gt,c,d) |
798 |
|
IVEC_SELECT(s16,u16,4,gt,c,d) |
799 |
|
IVEC_SELECT(s16,16,4,gt,c,d) |
800 |
|
IVEC_SELECT(s16,s16,4,lt,c,d) |
801 |
|
IVEC_SELECT(s16,u16,4,lt,c,d) |
802 |
|
IVEC_SELECT(s16,16,4,lt,c,d) |
803 |
|
IVEC_SELECT(s16,s16,4,le,c,d) |
804 |
|
IVEC_SELECT(s16,u16,4,le,c,d) |
805 |
|
IVEC_SELECT(s16,16,4,le,c,d) |
806 |
|
IVEC_SELECT(s16,s16,4,ge,c,d) |
807 |
|
IVEC_SELECT(s16,u16,4,ge,c,d) |
808 |
|
IVEC_SELECT(s16,16,4,ge,c,d) |
809 |
|
|
810 |
|
IVEC_SELECT(s32,s32,2,gt,c,d) |
811 |
|
IVEC_SELECT(s32,u32,2,gt,c,d) |
812 |
|
IVEC_SELECT(s32,32,2,gt,c,d) |
813 |
|
IVEC_SELECT(s32,s32,2,lt,c,d) |
814 |
|
IVEC_SELECT(s32,u32,2,lt,c,d) |
815 |
|
IVEC_SELECT(s32,32,2,lt,c,d) |
816 |
|
IVEC_SELECT(s32,s32,2,le,c,d) |
817 |
|
IVEC_SELECT(s32,u32,2,le,c,d) |
818 |
|
IVEC_SELECT(s32,32,2,le,c,d) |
819 |
|
IVEC_SELECT(s32,s32,2,ge,c,d) |
820 |
|
IVEC_SELECT(s32,u32,2,ge,c,d) |
821 |
|
IVEC_SELECT(s32,32,2,ge,c,d) |
822 |
|
|
823 |
|
|
824 |
|
#undef IVEC_SELECT |
825 |
|
|
826 |
|
inline static void empty(void) { _m_empty(); } |
827 |
|
|
828 |
|
#if defined(_SILENCE_IVEC_C4799) |
829 |
|
#pragma warning(pop) |
830 |
|
#endif |
831 |
|
|
832 |
|
#endif /* defined(_M_CEE_PURE) */ |
833 |
|
|
834 |
|
#endif /* RC_INVOKED */ |
835 |
|
#endif /* _IVEC_H_INCLUDED */ |
836 |
|
|
|
|
|