Meg's Mirrors

zig

1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef HEXAGON_TYPES_H
10	#define HEXAGON_TYPES_H
11
12	#include <hexagon_protos.h>
13
14	// Save and undefine B0 to avoid conflicts with POSIX termios.h which
15	// defines B0 as a macro for baud rate 0.
16	#pragma push_macro("B0")
17	#undef B0
18
19	/* Hexagon names */
20	#define HEXAGON_Vect HEXAGON_Vect64
21	#define HEXAGON_V_GET_D HEXAGON_V64_GET_D
22	#define HEXAGON_V_GET_UD HEXAGON_V64_GET_UD
23	#define HEXAGON_V_GET_W0 HEXAGON_V64_GET_W0
24	#define HEXAGON_V_GET_W1 HEXAGON_V64_GET_W1
25	#define HEXAGON_V_GET_UW0 HEXAGON_V64_GET_UW0
26	#define HEXAGON_V_GET_UW1 HEXAGON_V64_GET_UW1
27	#define HEXAGON_V_GET_H0 HEXAGON_V64_GET_H0
28	#define HEXAGON_V_GET_H1 HEXAGON_V64_GET_H1
29	#define HEXAGON_V_GET_H2 HEXAGON_V64_GET_H2
30	#define HEXAGON_V_GET_H3 HEXAGON_V64_GET_H3
31	#define HEXAGON_V_GET_UH0 HEXAGON_V64_GET_UH0
32	#define HEXAGON_V_GET_UH1 HEXAGON_V64_GET_UH1
33	#define HEXAGON_V_GET_UH2 HEXAGON_V64_GET_UH2
34	#define HEXAGON_V_GET_UH3 HEXAGON_V64_GET_UH3
35	#define HEXAGON_V_GET_B0 HEXAGON_V64_GET_B0
36	#define HEXAGON_V_GET_B1 HEXAGON_V64_GET_B1
37	#define HEXAGON_V_GET_B2 HEXAGON_V64_GET_B2
38	#define HEXAGON_V_GET_B3 HEXAGON_V64_GET_B3
39	#define HEXAGON_V_GET_B4 HEXAGON_V64_GET_B4
40	#define HEXAGON_V_GET_B5 HEXAGON_V64_GET_B5
41	#define HEXAGON_V_GET_B6 HEXAGON_V64_GET_B6
42	#define HEXAGON_V_GET_B7 HEXAGON_V64_GET_B7
43	#define HEXAGON_V_GET_UB0 HEXAGON_V64_GET_UB0
44	#define HEXAGON_V_GET_UB1 HEXAGON_V64_GET_UB1
45	#define HEXAGON_V_GET_UB2 HEXAGON_V64_GET_UB2
46	#define HEXAGON_V_GET_UB3 HEXAGON_V64_GET_UB3
47	#define HEXAGON_V_GET_UB4 HEXAGON_V64_GET_UB4
48	#define HEXAGON_V_GET_UB5 HEXAGON_V64_GET_UB5
49	#define HEXAGON_V_GET_UB6 HEXAGON_V64_GET_UB6
50	#define HEXAGON_V_GET_UB7 HEXAGON_V64_GET_UB7
51	#define HEXAGON_V_PUT_D HEXAGON_V64_PUT_D
52	#define HEXAGON_V_PUT_W0 HEXAGON_V64_PUT_W0
53	#define HEXAGON_V_PUT_W1 HEXAGON_V64_PUT_W1
54	#define HEXAGON_V_PUT_H0 HEXAGON_V64_PUT_H0
55	#define HEXAGON_V_PUT_H1 HEXAGON_V64_PUT_H1
56	#define HEXAGON_V_PUT_H2 HEXAGON_V64_PUT_H2
57	#define HEXAGON_V_PUT_H3 HEXAGON_V64_PUT_H3
58	#define HEXAGON_V_PUT_B0 HEXAGON_V64_PUT_B0
59	#define HEXAGON_V_PUT_B1 HEXAGON_V64_PUT_B1
60	#define HEXAGON_V_PUT_B2 HEXAGON_V64_PUT_B2
61	#define HEXAGON_V_PUT_B3 HEXAGON_V64_PUT_B3
62	#define HEXAGON_V_PUT_B4 HEXAGON_V64_PUT_B4
63	#define HEXAGON_V_PUT_B5 HEXAGON_V64_PUT_B5
64	#define HEXAGON_V_PUT_B6 HEXAGON_V64_PUT_B6
65	#define HEXAGON_V_PUT_B7 HEXAGON_V64_PUT_B7
66	#define HEXAGON_V_CREATE_D HEXAGON_V64_CREATE_D
67	#define HEXAGON_V_CREATE_W HEXAGON_V64_CREATE_W
68	#define HEXAGON_V_CREATE_H HEXAGON_V64_CREATE_H
69	#define HEXAGON_V_CREATE_B HEXAGON_V64_CREATE_B
70
71	#ifdef __cplusplus
72	#define HEXAGON_VectC HEXAGON_Vect64C
73	#endif /* __cplusplus */
74
75	/* 64 Bit Vectors */
76
77	typedef long long __attribute__((__may_alias__)) HEXAGON_Vect64;
78
79	/* Extract doubleword macros */
80
81	#define HEXAGON_V64_GET_D(v) (v)
82	#define HEXAGON_V64_GET_UD(v) ((unsigned long long)(v))
83
84	/* Extract word macros */
85
86	#define HEXAGON_V64_GET_W0(v) \
87	__extension__({ \
88	union { \
89	long long d; \
90	int w[2]; \
91	} _HEXAGON_V64_internal_union; \
92	_HEXAGON_V64_internal_union.d = (v); \
93	_HEXAGON_V64_internal_union.w[0]; \
94	})
95	#define HEXAGON_V64_GET_W1(v) \
96	__extension__({ \
97	union { \
98	long long d; \
99	int w[2]; \
100	} _HEXAGON_V64_internal_union; \
101	_HEXAGON_V64_internal_union.d = (v); \
102	_HEXAGON_V64_internal_union.w[1]; \
103	})
104	#define HEXAGON_V64_GET_UW0(v) \
105	__extension__({ \
106	union { \
107	long long d; \
108	unsigned int uw[2]; \
109	} _HEXAGON_V64_internal_union; \
110	_HEXAGON_V64_internal_union.d = (v); \
111	_HEXAGON_V64_internal_union.uw[0]; \
112	})
113	#define HEXAGON_V64_GET_UW1(v) \
114	__extension__({ \
115	union { \
116	long long d; \
117	unsigned int uw[2]; \
118	} _HEXAGON_V64_internal_union; \
119	_HEXAGON_V64_internal_union.d = (v); \
120	_HEXAGON_V64_internal_union.uw[1]; \
121	})
122
123	/* Extract half word macros */
124
125	#define HEXAGON_V64_GET_H0(v) \
126	__extension__({ \
127	union { \
128	long long d; \
129	short h[4]; \
130	} _HEXAGON_V64_internal_union; \
131	_HEXAGON_V64_internal_union.d = (v); \
132	_HEXAGON_V64_internal_union.h[0]; \
133	})
134	#define HEXAGON_V64_GET_H1(v) \
135	__extension__({ \
136	union { \
137	long long d; \
138	short h[4]; \
139	} _HEXAGON_V64_internal_union; \
140	_HEXAGON_V64_internal_union.d = (v); \
141	_HEXAGON_V64_internal_union.h[1]; \
142	})
143	#define HEXAGON_V64_GET_H2(v) \
144	__extension__({ \
145	union { \
146	long long d; \
147	short h[4]; \
148	} _HEXAGON_V64_internal_union; \
149	_HEXAGON_V64_internal_union.d = (v); \
150	_HEXAGON_V64_internal_union.h[2]; \
151	})
152	#define HEXAGON_V64_GET_H3(v) \
153	__extension__({ \
154	union { \
155	long long d; \
156	short h[4]; \
157	} _HEXAGON_V64_internal_union; \
158	_HEXAGON_V64_internal_union.d = (v); \
159	_HEXAGON_V64_internal_union.h[3]; \
160	})
161	#define HEXAGON_V64_GET_UH0(v) \
162	__extension__({ \
163	union { \
164	long long d; \
165	unsigned short uh[4]; \
166	} _HEXAGON_V64_internal_union; \
167	_HEXAGON_V64_internal_union.d = (v); \
168	_HEXAGON_V64_internal_union.uh[0]; \
169	})
170	#define HEXAGON_V64_GET_UH1(v) \
171	__extension__({ \
172	union { \
173	long long d; \
174	unsigned short uh[4]; \
175	} _HEXAGON_V64_internal_union; \
176	_HEXAGON_V64_internal_union.d = (v); \
177	_HEXAGON_V64_internal_union.uh[1]; \
178	})
179	#define HEXAGON_V64_GET_UH2(v) \
180	__extension__({ \
181	union { \
182	long long d; \
183	unsigned short uh[4]; \
184	} _HEXAGON_V64_internal_union; \
185	_HEXAGON_V64_internal_union.d = (v); \
186	_HEXAGON_V64_internal_union.uh[2]; \
187	})
188	#define HEXAGON_V64_GET_UH3(v) \
189	__extension__({ \
190	union { \
191	long long d; \
192	unsigned short uh[4]; \
193	} _HEXAGON_V64_internal_union; \
194	_HEXAGON_V64_internal_union.d = (v); \
195	_HEXAGON_V64_internal_union.uh[3]; \
196	})
197
198	/* Extract byte macros */
199
200	#define HEXAGON_V64_GET_B0(v) \
201	__extension__({ \
202	union { \
203	long long d; \
204	signed char b[8]; \
205	} _HEXAGON_V64_internal_union; \
206	_HEXAGON_V64_internal_union.d = (v); \
207	_HEXAGON_V64_internal_union.b[0]; \
208	})
209	#define HEXAGON_V64_GET_B1(v) \
210	__extension__({ \
211	union { \
212	long long d; \
213	signed char b[8]; \
214	} _HEXAGON_V64_internal_union; \
215	_HEXAGON_V64_internal_union.d = (v); \
216	_HEXAGON_V64_internal_union.b[1]; \
217	})
218	#define HEXAGON_V64_GET_B2(v) \
219	__extension__({ \
220	union { \
221	long long d; \
222	signed char b[8]; \
223	} _HEXAGON_V64_internal_union; \
224	_HEXAGON_V64_internal_union.d = (v); \
225	_HEXAGON_V64_internal_union.b[2]; \
226	})
227	#define HEXAGON_V64_GET_B3(v) \
228	__extension__({ \
229	union { \
230	long long d; \
231	signed char b[8]; \
232	} _HEXAGON_V64_internal_union; \
233	_HEXAGON_V64_internal_union.d = (v); \
234	_HEXAGON_V64_internal_union.b[3]; \
235	})
236	#define HEXAGON_V64_GET_B4(v) \
237	__extension__({ \
238	union { \
239	long long d; \
240	signed char b[8]; \
241	} _HEXAGON_V64_internal_union; \
242	_HEXAGON_V64_internal_union.d = (v); \
243	_HEXAGON_V64_internal_union.b[4]; \
244	})
245	#define HEXAGON_V64_GET_B5(v) \
246	__extension__({ \
247	union { \
248	long long d; \
249	signed char b[8]; \
250	} _HEXAGON_V64_internal_union; \
251	_HEXAGON_V64_internal_union.d = (v); \
252	_HEXAGON_V64_internal_union.b[5]; \
253	})
254	#define HEXAGON_V64_GET_B6(v) \
255	__extension__({ \
256	union { \
257	long long d; \
258	signed char b[8]; \
259	} _HEXAGON_V64_internal_union; \
260	_HEXAGON_V64_internal_union.d = (v); \
261	_HEXAGON_V64_internal_union.b[6]; \
262	})
263	#define HEXAGON_V64_GET_B7(v) \
264	__extension__({ \
265	union { \
266	long long d; \
267	signed char b[8]; \
268	} _HEXAGON_V64_internal_union; \
269	_HEXAGON_V64_internal_union.d = (v); \
270	_HEXAGON_V64_internal_union.b[7]; \
271	})
272	#define HEXAGON_V64_GET_UB0(v) \
273	__extension__({ \
274	union { \
275	long long d; \
276	unsigned char ub[8]; \
277	} _HEXAGON_V64_internal_union; \
278	_HEXAGON_V64_internal_union.d = (v); \
279	_HEXAGON_V64_internal_union.ub[0]; \
280	})
281	#define HEXAGON_V64_GET_UB1(v) \
282	__extension__({ \
283	union { \
284	long long d; \
285	unsigned char ub[8]; \
286	} _HEXAGON_V64_internal_union; \
287	_HEXAGON_V64_internal_union.d = (v); \
288	_HEXAGON_V64_internal_union.ub[1]; \
289	})
290	#define HEXAGON_V64_GET_UB2(v) \
291	__extension__({ \
292	union { \
293	long long d; \
294	unsigned char ub[8]; \
295	} _HEXAGON_V64_internal_union; \
296	_HEXAGON_V64_internal_union.d = (v); \
297	_HEXAGON_V64_internal_union.ub[2]; \
298	})
299	#define HEXAGON_V64_GET_UB3(v) \
300	__extension__({ \
301	union { \
302	long long d; \
303	unsigned char ub[8]; \
304	} _HEXAGON_V64_internal_union; \
305	_HEXAGON_V64_internal_union.d = (v); \
306	_HEXAGON_V64_internal_union.ub[3]; \
307	})
308	#define HEXAGON_V64_GET_UB4(v) \
309	__extension__({ \
310	union { \
311	long long d; \
312	unsigned char ub[8]; \
313	} _HEXAGON_V64_internal_union; \
314	_HEXAGON_V64_internal_union.d = (v); \
315	_HEXAGON_V64_internal_union.ub[4]; \
316	})
317	#define HEXAGON_V64_GET_UB5(v) \
318	__extension__({ \
319	union { \
320	long long d; \
321	unsigned char ub[8]; \
322	} _HEXAGON_V64_internal_union; \
323	_HEXAGON_V64_internal_union.d = (v); \
324	_HEXAGON_V64_internal_union.ub[5]; \
325	})
326	#define HEXAGON_V64_GET_UB6(v) \
327	__extension__({ \
328	union { \
329	long long d; \
330	unsigned char ub[8]; \
331	} _HEXAGON_V64_internal_union; \
332	_HEXAGON_V64_internal_union.d = (v); \
333	_HEXAGON_V64_internal_union.ub[6]; \
334	})
335	#define HEXAGON_V64_GET_UB7(v) \
336	__extension__({ \
337	union { \
338	long long d; \
339	unsigned char ub[8]; \
340	} _HEXAGON_V64_internal_union; \
341	_HEXAGON_V64_internal_union.d = (v); \
342	_HEXAGON_V64_internal_union.ub[7]; \
343	})
344
345	/* NOTE: All set macros return a HEXAGON_Vect64 type */
346
347	/* Set doubleword macro */
348
349	#define HEXAGON_V64_PUT_D(v, new) (new)
350
351	/* Set word macros */
352
353	#ifdef __hexagon__
354
355	#define HEXAGON_V64_PUT_W0(v, new) \
356	__extension__({ \
357	union { \
358	long long d; \
359	int w[2]; \
360	} _HEXAGON_V64_internal_union; \
361	_HEXAGON_V64_internal_union.d = (v); \
362	_HEXAGON_V64_internal_union.w[0] = (new); \
363	_HEXAGON_V64_internal_union.d; \
364	})
365	#define HEXAGON_V64_PUT_W1(v, new) \
366	__extension__({ \
367	union { \
368	long long d; \
369	int w[2]; \
370	} _HEXAGON_V64_internal_union; \
371	_HEXAGON_V64_internal_union.d = (v); \
372	_HEXAGON_V64_internal_union.w[1] = (new); \
373	_HEXAGON_V64_internal_union.d; \
374	})
375
376	#else /* !__hexagon__ */
377
378	#define HEXAGON_V64_PUT_W0(v, new) \
379	(((v) & 0xffffffff00000000LL) | ((HEXAGON_Vect64)((unsigned int)(new))))
380	#define HEXAGON_V64_PUT_W1(v, new) \
381	(((v) & 0x00000000ffffffffLL) | (((HEXAGON_Vect64)(new)) << 32LL))
382
383	#endif /* !__hexagon__ */
384
385	/* Set half word macros */
386
387	#ifdef __hexagon__
388
389	#define HEXAGON_V64_PUT_H0(v, new) \
390	__extension__({ \
391	union { \
392	long long d; \
393	short h[4]; \
394	} _HEXAGON_V64_internal_union; \
395	_HEXAGON_V64_internal_union.d = (v); \
396	_HEXAGON_V64_internal_union.h[0] = (new); \
397	_HEXAGON_V64_internal_union.d; \
398	})
399	#define HEXAGON_V64_PUT_H1(v, new) \
400	__extension__({ \
401	union { \
402	long long d; \
403	short h[4]; \
404	} _HEXAGON_V64_internal_union; \
405	_HEXAGON_V64_internal_union.d = (v); \
406	_HEXAGON_V64_internal_union.h[1] = (new); \
407	_HEXAGON_V64_internal_union.d; \
408	})
409	#define HEXAGON_V64_PUT_H2(v, new) \
410	__extension__({ \
411	union { \
412	long long d; \
413	short h[4]; \
414	} _HEXAGON_V64_internal_union; \
415	_HEXAGON_V64_internal_union.d = (v); \
416	_HEXAGON_V64_internal_union.h[2] = (new); \
417	_HEXAGON_V64_internal_union.d; \
418	})
419	#define HEXAGON_V64_PUT_H3(v, new) \
420	__extension__({ \
421	union { \
422	long long d; \
423	short h[4]; \
424	} _HEXAGON_V64_internal_union; \
425	_HEXAGON_V64_internal_union.d = (v); \
426	_HEXAGON_V64_internal_union.h[3] = (new); \
427	_HEXAGON_V64_internal_union.d; \
428	})
429
430	#else /* !__hexagon__ */
431
432	#define HEXAGON_V64_PUT_H0(v, new) \
433	(((v) & 0xffffffffffff0000LL) | ((HEXAGON_Vect64)((unsigned short)(new))))
434	#define HEXAGON_V64_PUT_H1(v, new) \
435	(((v) & 0xffffffff0000ffffLL) | (((HEXAGON_Vect64)((unsigned short)(new))) << 16LL))
436	#define HEXAGON_V64_PUT_H2(v, new) \
437	(((v) & 0xffff0000ffffffffLL) | (((HEXAGON_Vect64)((unsigned short)(new))) << 32LL))
438	#define HEXAGON_V64_PUT_H3(v, new) \
439	(((v) & 0x0000ffffffffffffLL) | (((HEXAGON_Vect64)(new)) << 48LL))
440
441	#endif /* !__hexagon__ */
442
443	/* Set byte macros */
444
445	#ifdef __hexagon__
446
447	#define HEXAGON_V64_PUT_B0(v, new) \
448	__extension__({ \
449	union { \
450	long long d; \
451	char b[8]; \
452	} _HEXAGON_V64_internal_union; \
453	_HEXAGON_V64_internal_union.d = (v); \
454	_HEXAGON_V64_internal_union.b[0] = (new); \
455	_HEXAGON_V64_internal_union.d; \
456	})
457	#define HEXAGON_V64_PUT_B1(v, new) \
458	__extension__({ \
459	union { \
460	long long d; \
461	char b[8]; \
462	} _HEXAGON_V64_internal_union; \
463	_HEXAGON_V64_internal_union.d = (v); \
464	_HEXAGON_V64_internal_union.b[1] = (new); \
465	_HEXAGON_V64_internal_union.d; \
466	})
467	#define HEXAGON_V64_PUT_B2(v, new) \
468	__extension__({ \
469	union { \
470	long long d; \
471	char b[8]; \
472	} _HEXAGON_V64_internal_union; \
473	_HEXAGON_V64_internal_union.d = (v); \
474	_HEXAGON_V64_internal_union.b[2] = (new); \
475	_HEXAGON_V64_internal_union.d; \
476	})
477	#define HEXAGON_V64_PUT_B3(v, new) \
478	__extension__({ \
479	union { \
480	long long d; \
481	char b[8]; \
482	} _HEXAGON_V64_internal_union; \
483	_HEXAGON_V64_internal_union.d = (v); \
484	_HEXAGON_V64_internal_union.b[3] = (new); \
485	_HEXAGON_V64_internal_union.d; \
486	})
487	#define HEXAGON_V64_PUT_B4(v, new) \
488	__extension__({ \
489	union { \
490	long long d; \
491	char b[8]; \
492	} _HEXAGON_V64_internal_union; \
493	_HEXAGON_V64_internal_union.d = (v); \
494	_HEXAGON_V64_internal_union.b[4] = (new); \
495	_HEXAGON_V64_internal_union.d; \
496	})
497	#define HEXAGON_V64_PUT_B5(v, new) \
498	__extension__({ \
499	union { \
500	long long d; \
501	char b[8]; \
502	} _HEXAGON_V64_internal_union; \
503	_HEXAGON_V64_internal_union.d = (v); \
504	_HEXAGON_V64_internal_union.b[5] = (new); \
505	_HEXAGON_V64_internal_union.d; \
506	})
507	#define HEXAGON_V64_PUT_B6(v, new) \
508	__extension__({ \
509	union { \
510	long long d; \
511	char b[8]; \
512	} _HEXAGON_V64_internal_union; \
513	_HEXAGON_V64_internal_union.d = (v); \
514	_HEXAGON_V64_internal_union.b[6] = (new); \
515	_HEXAGON_V64_internal_union.d; \
516	})
517	#define HEXAGON_V64_PUT_B7(v, new) \
518	__extension__({ \
519	union { \
520	long long d; \
521	char b[8]; \
522	} _HEXAGON_V64_internal_union; \
523	_HEXAGON_V64_internal_union.d = (v); \
524	_HEXAGON_V64_internal_union.b[7] = (new); \
525	_HEXAGON_V64_internal_union.d; \
526	})
527
528	#else /* !__hexagon__ */
529
530	#define HEXAGON_V64_PUT_B0(v, new) \
531	(((v) & 0xffffffffffffff00LL) | ((HEXAGON_Vect64)((unsigned char)(new))))
532	#define HEXAGON_V64_PUT_B1(v, new) \
533	(((v) & 0xffffffffffff00ffLL) | (((HEXAGON_Vect64)((unsigned char)(new))) << 8LL))
534	#define HEXAGON_V64_PUT_B2(v, new) \
535	(((v) & 0xffffffffff00ffffLL) | (((HEXAGON_Vect64)((unsigned char)(new))) << 16LL))
536	#define HEXAGON_V64_PUT_B3(v, new) \
537	(((v) & 0xffffffff00ffffffLL) | (((HEXAGON_Vect64)((unsigned char)(new))) << 24LL))
538	#define HEXAGON_V64_PUT_B4(v, new) \
539	(((v) & 0xffffff00ffffffffLL) | (((HEXAGON_Vect64)((unsigned char)(new))) << 32LL))
540	#define HEXAGON_V64_PUT_B5(v, new) \
541	(((v) & 0xffff00ffffffffffLL) | (((HEXAGON_Vect64)((unsigned char)(new))) << 40LL))
542	#define HEXAGON_V64_PUT_B6(v, new) \
543	(((v) & 0xff00ffffffffffffLL) | (((HEXAGON_Vect64)((unsigned char)(new))) << 48LL))
544	#define HEXAGON_V64_PUT_B7(v, new) \
545	(((v) & 0x00ffffffffffffffLL) | (((HEXAGON_Vect64)(new)) << 56LL))
546
547	#endif /* !__hexagon__ */
548
549	/* NOTE: All create macros return a HEXAGON_Vect64 type */
550
551	/* Create from a doubleword */
552
553	#define HEXAGON_V64_CREATE_D(d) (d)
554
555	/* Create from words */
556
557	#ifdef __hexagon__
558
559	#define HEXAGON_V64_CREATE_W(w1, w0) \
560	__extension__({ \
561	union { \
562	long long d; \
563	int w[2]; \
564	} _HEXAGON_V64_internal_union; \
565	_HEXAGON_V64_internal_union.w[0] = (w0); \
566	_HEXAGON_V64_internal_union.w[1] = (w1); \
567	_HEXAGON_V64_internal_union.d; \
568	})
569
570	#else /* !__hexagon__ */
571
572	#define HEXAGON_V64_CREATE_W(w1, w0) \
573	((((HEXAGON_Vect64)(w1)) << 32LL) | ((HEXAGON_Vect64)((w0) & 0xffffffff)))
574
575	#endif /* !__hexagon__ */
576
577	/* Create from half words */
578
579	#ifdef __hexagon__
580
581	#define HEXAGON_V64_CREATE_H(h3, h2, h1, h0) \
582	__extension__({ \
583	union { \
584	long long d; \
585	short h[4]; \
586	} _HEXAGON_V64_internal_union; \
587	_HEXAGON_V64_internal_union.h[0] = (h0); \
588	_HEXAGON_V64_internal_union.h[1] = (h1); \
589	_HEXAGON_V64_internal_union.h[2] = (h2); \
590	_HEXAGON_V64_internal_union.h[3] = (h3); \
591	_HEXAGON_V64_internal_union.d; \
592	})
593
594	#else /* !__hexagon__ */
595
596	#define HEXAGON_V64_CREATE_H(h3, h2, h1, h0) \
597	((((HEXAGON_Vect64)(h3)) << 48LL) | (((HEXAGON_Vect64)((h2) & 0xffff)) << 32LL) | \
598	(((HEXAGON_Vect64)((h1) & 0xffff)) << 16LL) | ((HEXAGON_Vect64)((h0) & 0xffff)))
599
600	#endif /* !__hexagon__ */
601
602	/* Create from bytes */
603
604	#ifdef __hexagon__
605
606	#define HEXAGON_V64_CREATE_B(b7, b6, b5, b4, b3, b2, b1, b0) \
607	__extension__({ \
608	union { \
609	long long d; \
610	char b[8]; \
611	} _HEXAGON_V64_internal_union; \
612	_HEXAGON_V64_internal_union.b[0] = (b0); \
613	_HEXAGON_V64_internal_union.b[1] = (b1); \
614	_HEXAGON_V64_internal_union.b[2] = (b2); \
615	_HEXAGON_V64_internal_union.b[3] = (b3); \
616	_HEXAGON_V64_internal_union.b[4] = (b4); \
617	_HEXAGON_V64_internal_union.b[5] = (b5); \
618	_HEXAGON_V64_internal_union.b[6] = (b6); \
619	_HEXAGON_V64_internal_union.b[7] = (b7); \
620	_HEXAGON_V64_internal_union.d; \
621	})
622
623	#else /* !__hexagon__ */
624
625	#define HEXAGON_V64_CREATE_B(b7, b6, b5, b4, b3, b2, b1, b0) \
626	((((HEXAGON_Vect64)(b7)) << 56LL) | (((HEXAGON_Vect64)((b6) & 0xff)) << 48LL) | \
627	(((HEXAGON_Vect64)((b5) & 0xff)) << 40LL) | (((HEXAGON_Vect64)((b4) & 0xff)) << 32LL) | \
628	(((HEXAGON_Vect64)((b3) & 0xff)) << 24LL) | (((HEXAGON_Vect64)((b2) & 0xff)) << 16LL) | \
629	(((HEXAGON_Vect64)((b1) & 0xff)) << 8LL) | ((HEXAGON_Vect64)((b0) & 0xff)))
630
631	#endif /* !__hexagon__ */
632
633	#ifdef __cplusplus
634
635	class HEXAGON_Vect64C {
636	public:
637	// Constructors
638	HEXAGON_Vect64C(long long d = 0) : data(d) {};
639	HEXAGON_Vect64C(int w1, int w0) : data(HEXAGON_V64_CREATE_W(w1, w0)) {};
640	HEXAGON_Vect64C(short h3, short h2, short h1, short h0)
641	: data(HEXAGON_V64_CREATE_H(h3, h2, h1, h0)) {};
642	HEXAGON_Vect64C(signed char b7, signed char b6, signed char b5, signed char b4,
643	signed char b3, signed char b2, signed char b1, signed char b0)
644	: data(HEXAGON_V64_CREATE_B(b7, b6, b5, b4, b3, b2, b1, b0)) {};
645	HEXAGON_Vect64C(const HEXAGON_Vect64C &v) : data(v.data) {};
646
647	HEXAGON_Vect64C &operator=(const HEXAGON_Vect64C &v) {
648	data = v.data;
649	return *this;
650	};
651
652	operator long long() {
653	return data;
654	};
655
656	// Extract doubleword methods
657	long long D(void) {
658	return HEXAGON_V64_GET_D(data);
659	};
660	unsigned long long UD(void) {
661	return HEXAGON_V64_GET_UD(data);
662	};
663
664	// Extract word methods
665	int W0(void) {
666	return HEXAGON_V64_GET_W0(data);
667	};
668	int W1(void) {
669	return HEXAGON_V64_GET_W1(data);
670	};
671	unsigned int UW0(void) {
672	return HEXAGON_V64_GET_UW0(data);
673	};
674	unsigned int UW1(void) {
675	return HEXAGON_V64_GET_UW1(data);
676	};
677
678	// Extract half word methods
679	short H0(void) {
680	return HEXAGON_V64_GET_H0(data);
681	};
682	short H1(void) {
683	return HEXAGON_V64_GET_H1(data);
684	};
685	short H2(void) {
686	return HEXAGON_V64_GET_H2(data);
687	};
688	short H3(void) {
689	return HEXAGON_V64_GET_H3(data);
690	};
691	unsigned short UH0(void) {
692	return HEXAGON_V64_GET_UH0(data);
693	};
694	unsigned short UH1(void) {
695	return HEXAGON_V64_GET_UH1(data);
696	};
697	unsigned short UH2(void) {
698	return HEXAGON_V64_GET_UH2(data);
699	};
700	unsigned short UH3(void) {
701	return HEXAGON_V64_GET_UH3(data);
702	};
703
704	// Extract byte methods
705	signed char b0(void) { return HEXAGON_V64_GET_B0(data); };
706	signed char B0(void) { return b0(); };
707	signed char B1(void) {
708	return HEXAGON_V64_GET_B1(data);
709	};
710	signed char B2(void) {
711	return HEXAGON_V64_GET_B2(data);
712	};
713	signed char B3(void) {
714	return HEXAGON_V64_GET_B3(data);
715	};
716	signed char B4(void) {
717	return HEXAGON_V64_GET_B4(data);
718	};
719	signed char B5(void) {
720	return HEXAGON_V64_GET_B5(data);
721	};
722	signed char B6(void) {
723	return HEXAGON_V64_GET_B6(data);
724	};
725	signed char B7(void) {
726	return HEXAGON_V64_GET_B7(data);
727	};
728	unsigned char UB0(void) {
729	return HEXAGON_V64_GET_UB0(data);
730	};
731	unsigned char UB1(void) {
732	return HEXAGON_V64_GET_UB1(data);
733	};
734	unsigned char UB2(void) {
735	return HEXAGON_V64_GET_UB2(data);
736	};
737	unsigned char UB3(void) {
738	return HEXAGON_V64_GET_UB3(data);
739	};
740	unsigned char UB4(void) {
741	return HEXAGON_V64_GET_UB4(data);
742	};
743	unsigned char UB5(void) {
744	return HEXAGON_V64_GET_UB5(data);
745	};
746	unsigned char UB6(void) {
747	return HEXAGON_V64_GET_UB6(data);
748	};
749	unsigned char UB7(void) {
750	return HEXAGON_V64_GET_UB7(data);
751	};
752
753	// NOTE: All set methods return a HEXAGON_Vect64C type
754
755	// Set doubleword method
756	HEXAGON_Vect64C D(long long d) {
757	return HEXAGON_Vect64C(HEXAGON_V64_PUT_D(data, d));
758	};
759
760	// Set word methods
761	HEXAGON_Vect64C W0(int w) {
762	return HEXAGON_Vect64C(HEXAGON_V64_PUT_W0(data, w));
763	};
764	HEXAGON_Vect64C W1(int w) {
765	return HEXAGON_Vect64C(HEXAGON_V64_PUT_W1(data, w));
766	};
767
768	// Set half word methods
769	HEXAGON_Vect64C H0(short h) {
770	return HEXAGON_Vect64C(HEXAGON_V64_PUT_H0(data, h));
771	};
772	HEXAGON_Vect64C H1(short h) {
773	return HEXAGON_Vect64C(HEXAGON_V64_PUT_H1(data, h));
774	};
775	HEXAGON_Vect64C H2(short h) {
776	return HEXAGON_Vect64C(HEXAGON_V64_PUT_H2(data, h));
777	};
778	HEXAGON_Vect64C H3(short h) {
779	return HEXAGON_Vect64C(HEXAGON_V64_PUT_H3(data, h));
780	};
781
782	// Set byte methods
783	HEXAGON_Vect64C b0(signed char b) {
784	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B0(data, b));
785	};
786	HEXAGON_Vect64C B0(signed char b) { return b0(b); };
787	HEXAGON_Vect64C B1(signed char b) {
788	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B1(data, b));
789	};
790	HEXAGON_Vect64C B2(signed char b) {
791	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B2(data, b));
792	};
793	HEXAGON_Vect64C B3(signed char b) {
794	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B3(data, b));
795	};
796	HEXAGON_Vect64C B4(signed char b) {
797	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B4(data, b));
798	};
799	HEXAGON_Vect64C B5(signed char b) {
800	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B5(data, b));
801	};
802	HEXAGON_Vect64C B6(signed char b) {
803	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B6(data, b));
804	};
805	HEXAGON_Vect64C B7(signed char b) {
806	return HEXAGON_Vect64C(HEXAGON_V64_PUT_B7(data, b));
807	};
808
809	private:
810	long long data;
811	};
812
813	#endif /* __cplusplus */
814
815	/* 32 Bit Vectors */
816
817	typedef int HEXAGON_Vect32;
818
819	/* Extract word macros */
820
821	#define HEXAGON_V32_GET_W(v) (v)
822	#define HEXAGON_V32_GET_UW(v) ((unsigned int)(v))
823
824	/* Extract half word macros */
825
826	#define HEXAGON_V32_GET_H0(v) \
827	__extension__({ \
828	union { \
829	int w; \
830	short h[2]; \
831	} _HEXAGON_V32_internal_union; \
832	_HEXAGON_V32_internal_union.w = (v); \
833	_HEXAGON_V32_internal_union.h[0]; \
834	})
835	#define HEXAGON_V32_GET_H1(v) \
836	__extension__({ \
837	union { \
838	int w; \
839	short h[2]; \
840	} _HEXAGON_V32_internal_union; \
841	_HEXAGON_V32_internal_union.w = (v); \
842	_HEXAGON_V32_internal_union.h[1]; \
843	})
844	#define HEXAGON_V32_GET_UH0(v) \
845	__extension__({ \
846	union { \
847	int w; \
848	unsigned short uh[2]; \
849	} _HEXAGON_V32_internal_union; \
850	_HEXAGON_V32_internal_union.w = (v); \
851	_HEXAGON_V32_internal_union.uh[0]; \
852	})
853	#define HEXAGON_V32_GET_UH1(v) \
854	__extension__({ \
855	union { \
856	int w; \
857	unsigned short uh[2]; \
858	} _HEXAGON_V32_internal_union; \
859	_HEXAGON_V32_internal_union.w = (v); \
860	_HEXAGON_V32_internal_union.uh[1]; \
861	})
862
863	/* Extract byte macros */
864
865	#define HEXAGON_V32_GET_B0(v) \
866	__extension__({ \
867	union { \
868	int w; \
869	signed char b[4]; \
870	} _HEXAGON_V32_internal_union; \
871	_HEXAGON_V32_internal_union.w = (v); \
872	_HEXAGON_V32_internal_union.b[0]; \
873	})
874	#define HEXAGON_V32_GET_B1(v) \
875	__extension__({ \
876	union { \
877	int w; \
878	signed char b[4]; \
879	} _HEXAGON_V32_internal_union; \
880	_HEXAGON_V32_internal_union.w = (v); \
881	_HEXAGON_V32_internal_union.b[1]; \
882	})
883	#define HEXAGON_V32_GET_B2(v) \
884	__extension__({ \
885	union { \
886	int w; \
887	signed char b[4]; \
888	} _HEXAGON_V32_internal_union; \
889	_HEXAGON_V32_internal_union.w = (v); \
890	_HEXAGON_V32_internal_union.b[2]; \
891	})
892	#define HEXAGON_V32_GET_B3(v) \
893	__extension__({ \
894	union { \
895	int w; \
896	signed char b[4]; \
897	} _HEXAGON_V32_internal_union; \
898	_HEXAGON_V32_internal_union.w = (v); \
899	_HEXAGON_V32_internal_union.b[3]; \
900	})
901	#define HEXAGON_V32_GET_UB0(v) \
902	__extension__({ \
903	union { \
904	int w; \
905	unsigned char ub[4]; \
906	} _HEXAGON_V32_internal_union; \
907	_HEXAGON_V32_internal_union.w = (v); \
908	_HEXAGON_V32_internal_union.ub[0]; \
909	})
910	#define HEXAGON_V32_GET_UB1(v) \
911	__extension__({ \
912	union { \
913	int w; \
914	unsigned char ub[4]; \
915	} _HEXAGON_V32_internal_union; \
916	_HEXAGON_V32_internal_union.w = (v); \
917	_HEXAGON_V32_internal_union.ub[1]; \
918	})
919	#define HEXAGON_V32_GET_UB2(v) \
920	__extension__({ \
921	union { \
922	int w; \
923	unsigned char ub[4]; \
924	} _HEXAGON_V32_internal_union; \
925	_HEXAGON_V32_internal_union.w = (v); \
926	_HEXAGON_V32_internal_union.ub[2]; \
927	})
928	#define HEXAGON_V32_GET_UB3(v) \
929	__extension__({ \
930	union { \
931	int w; \
932	unsigned char ub[4]; \
933	} _HEXAGON_V32_internal_union; \
934	_HEXAGON_V32_internal_union.w = (v); \
935	_HEXAGON_V32_internal_union.ub[3]; \
936	})
937
938	/* NOTE: All set macros return a HEXAGON_Vect32 type */
939
940	/* Set word macro */
941
942	#define HEXAGON_V32_PUT_W(v, new) (new)
943
944	/* Set half word macros */
945
946	#ifdef __hexagon__
947
948	#define HEXAGON_V32_PUT_H0(v, new) \
949	__extension__({ \
950	union { \
951	int w; \
952	short h[2]; \
953	} _HEXAGON_V32_internal_union; \
954	_HEXAGON_V32_internal_union.w = (v); \
955	_HEXAGON_V32_internal_union.h[0] = (new); \
956	_HEXAGON_V32_internal_union.w; \
957	})
958	#define HEXAGON_V32_PUT_H1(v, new) \
959	__extension__({ \
960	union { \
961	int w; \
962	short h[2]; \
963	} _HEXAGON_V32_internal_union; \
964	_HEXAGON_V32_internal_union.w = (v); \
965	_HEXAGON_V32_internal_union.h[1] = (new); \
966	_HEXAGON_V32_internal_union.w; \
967	})
968
969	#else /* !__hexagon__ */
970
971	#define HEXAGON_V32_PUT_H0(v, new) \
972	(((v) & 0xffff0000) | ((HEXAGON_Vect32)((unsigned short)(new))))
973	#define HEXAGON_V32_PUT_H1(v, new) (((v) & 0x0000ffff) | (((HEXAGON_Vect32)(new)) << 16))
974
975	#endif /* !__hexagon__ */
976
977	/* Set byte macros */
978
979	#ifdef __hexagon__
980
981	#define HEXAGON_V32_PUT_B0(v, new) \
982	__extension__({ \
983	union { \
984	int w; \
985	char b[4]; \
986	} _HEXAGON_V32_internal_union; \
987	_HEXAGON_V32_internal_union.w = (v); \
988	_HEXAGON_V32_internal_union.b[0] = (new); \
989	_HEXAGON_V32_internal_union.w; \
990	})
991	#define HEXAGON_V32_PUT_B1(v, new) \
992	__extension__({ \
993	union { \
994	int w; \
995	char b[4]; \
996	} _HEXAGON_V32_internal_union; \
997	_HEXAGON_V32_internal_union.w = (v); \
998	_HEXAGON_V32_internal_union.b[1] = (new); \
999	_HEXAGON_V32_internal_union.w; \
1000	})
1001	#define HEXAGON_V32_PUT_B2(v, new) \
1002	__extension__({ \
1003	union { \
1004	int w; \
1005	char b[4]; \
1006	} _HEXAGON_V32_internal_union; \
1007	_HEXAGON_V32_internal_union.w = (v); \
1008	_HEXAGON_V32_internal_union.b[2] = (new); \
1009	_HEXAGON_V32_internal_union.w; \
1010	})
1011	#define HEXAGON_V32_PUT_B3(v, new) \
1012	__extension__({ \
1013	union { \
1014	int w; \
1015	char b[4]; \
1016	} _HEXAGON_V32_internal_union; \
1017	_HEXAGON_V32_internal_union.w = (v); \
1018	_HEXAGON_V32_internal_union.b[3] = (new); \
1019	_HEXAGON_V32_internal_union.w; \
1020	})
1021
1022	#else /* !__hexagon__ */
1023
1024	#define HEXAGON_V32_PUT_B0(v, new) \
1025	(((v) & 0xffffff00) | ((HEXAGON_Vect32)((unsigned char)(new))))
1026	#define HEXAGON_V32_PUT_B1(v, new) \
1027	(((v) & 0xffff00ff) | (((HEXAGON_Vect32)((unsigned char)(new))) << 8))
1028	#define HEXAGON_V32_PUT_B2(v, new) \
1029	(((v) & 0xff00ffff) | (((HEXAGON_Vect32)((unsigned char)(new))) << 16))
1030	#define HEXAGON_V32_PUT_B3(v, new) (((v) & 0x00ffffff) | (((HEXAGON_Vect32)(new)) << 24))
1031
1032	#endif /* !__hexagon__ */
1033
1034	/* NOTE: All create macros return a HEXAGON_Vect32 type */
1035
1036	/* Create from a word */
1037
1038	#define HEXAGON_V32_CREATE_W(w) (w)
1039
1040	/* Create from half words */
1041
1042	#ifdef __hexagon__
1043
1044	#define HEXAGON_V32_CREATE_H(h1, h0) \
1045	__extension__({ \
1046	union { \
1047	long long d; \
1048	short h[2]; \
1049	} _HEXAGON_V32_internal_union; \
1050	_HEXAGON_V32_internal_union.h[0] = (h0); \
1051	_HEXAGON_V32_internal_union.h[1] = (h1); \
1052	_HEXAGON_V32_internal_union.d; \
1053	})
1054
1055	#else /* !__hexagon__ */
1056
1057	#define HEXAGON_V32_CREATE_H(h1, h0) \
1058	((((HEXAGON_Vect32)(h1)) << 16) | ((HEXAGON_Vect32)((h0) & 0xffff)))
1059
1060	#endif /* !__hexagon__ */
1061
1062	/* Create from bytes */
1063	#ifdef __hexagon__
1064
1065	#define HEXAGON_V32_CREATE_B(b3, b2, b1, b0) \
1066	__extension__({ \
1067	union { \
1068	long long d; \
1069	char b[4]; \
1070	} _HEXAGON_V32_internal_union; \
1071	_HEXAGON_V32_internal_union.b[0] = (b0); \
1072	_HEXAGON_V32_internal_union.b[1] = (b1); \
1073	_HEXAGON_V32_internal_union.b[2] = (b2); \
1074	_HEXAGON_V32_internal_union.b[3] = (b3); \
1075	_HEXAGON_V32_internal_union.d; \
1076	})
1077
1078	#else /* !__hexagon__ */
1079
1080	#define HEXAGON_V32_CREATE_B(b3, b2, b1, b0) \
1081	((((HEXAGON_Vect32)(b3)) << 24) | (((HEXAGON_Vect32)((b2) & 0xff)) << 16) | \
1082	(((HEXAGON_Vect32)((b1) & 0xff)) << 8) | ((HEXAGON_Vect32)((b0) & 0xff)))
1083
1084	#endif /* !__hexagon__ */
1085
1086	#ifdef __cplusplus
1087
1088	class HEXAGON_Vect32C {
1089	public:
1090	// Constructors
1091	HEXAGON_Vect32C(int w = 0) : data(w) {};
1092	HEXAGON_Vect32C(short h1, short h0) : data(HEXAGON_V32_CREATE_H(h1, h0)) {};
1093	HEXAGON_Vect32C(signed char b3, signed char b2, signed char b1, signed char b0)
1094	: data(HEXAGON_V32_CREATE_B(b3, b2, b1, b0)) {};
1095	HEXAGON_Vect32C(const HEXAGON_Vect32C &v) : data(v.data) {};
1096
1097	HEXAGON_Vect32C &operator=(const HEXAGON_Vect32C &v) {
1098	data = v.data;
1099	return *this;
1100	};
1101
1102	operator int() {
1103	return data;
1104	};
1105
1106	// Extract word methods
1107	int W(void) {
1108	return HEXAGON_V32_GET_W(data);
1109	};
1110	unsigned int UW(void) {
1111	return HEXAGON_V32_GET_UW(data);
1112	};
1113
1114	// Extract half word methods
1115	short H0(void) {
1116	return HEXAGON_V32_GET_H0(data);
1117	};
1118	short H1(void) {
1119	return HEXAGON_V32_GET_H1(data);
1120	};
1121	unsigned short UH0(void) {
1122	return HEXAGON_V32_GET_UH0(data);
1123	};
1124	unsigned short UH1(void) {
1125	return HEXAGON_V32_GET_UH1(data);
1126	};
1127
1128	// Extract byte methods
1129	signed char b0(void) { return HEXAGON_V32_GET_B0(data); };
1130	signed char B0(void) { return b0(); };
1131	signed char B1(void) {
1132	return HEXAGON_V32_GET_B1(data);
1133	};
1134	signed char B2(void) {
1135	return HEXAGON_V32_GET_B2(data);
1136	};
1137	signed char B3(void) {
1138	return HEXAGON_V32_GET_B3(data);
1139	};
1140	unsigned char UB0(void) {
1141	return HEXAGON_V32_GET_UB0(data);
1142	};
1143	unsigned char UB1(void) {
1144	return HEXAGON_V32_GET_UB1(data);
1145	};
1146	unsigned char UB2(void) {
1147	return HEXAGON_V32_GET_UB2(data);
1148	};
1149	unsigned char UB3(void) {
1150	return HEXAGON_V32_GET_UB3(data);
1151	};
1152
1153	// NOTE: All set methods return a HEXAGON_Vect32C type
1154
1155	// Set word method
1156	HEXAGON_Vect32C W(int w) {
1157	return HEXAGON_Vect32C(HEXAGON_V32_PUT_W(data, w));
1158	};
1159
1160	// Set half word methods
1161	HEXAGON_Vect32C H0(short h) {
1162	return HEXAGON_Vect32C(HEXAGON_V32_PUT_H0(data, h));
1163	};
1164	HEXAGON_Vect32C H1(short h) {
1165	return HEXAGON_Vect32C(HEXAGON_V32_PUT_H1(data, h));
1166	};
1167
1168	// Set byte methods
1169	HEXAGON_Vect32C b0(signed char b) {
1170	return HEXAGON_Vect32C(HEXAGON_V32_PUT_B0(data, b));
1171	};
1172	HEXAGON_Vect32C B0(signed char b) { return b0(b); };
1173	HEXAGON_Vect32C B1(signed char b) {
1174	return HEXAGON_Vect32C(HEXAGON_V32_PUT_B1(data, b));
1175	};
1176	HEXAGON_Vect32C B2(signed char b) {
1177	return HEXAGON_Vect32C(HEXAGON_V32_PUT_B2(data, b));
1178	};
1179	HEXAGON_Vect32C B3(signed char b) {
1180	return HEXAGON_Vect32C(HEXAGON_V32_PUT_B3(data, b));
1181	};
1182
1183	private:
1184	int data;
1185	};
1186
1187	#endif /* __cplusplus */
1188
1189	// V65 Vector types
1190	#if __HVX_ARCH__ >= 65
1191	#if defined __HVX__ && (__HVX_LENGTH__ == 128)
1192	typedef long HEXAGON_VecPred128 __attribute__((__vector_size__(128)))
1193	__attribute__((aligned(128)));
1194
1195	typedef long HEXAGON_Vect1024 __attribute__((__vector_size__(128)))
1196	__attribute__((aligned(128)));
1197
1198	typedef long HEXAGON_Vect2048 __attribute__((__vector_size__(256)))
1199	__attribute__((aligned(256)));
1200
1201	typedef long HEXAGON_UVect1024 __attribute__((__vector_size__(128)))
1202	__attribute__((aligned(4)));
1203
1204	typedef long HEXAGON_UVect2048 __attribute__((__vector_size__(256)))
1205	__attribute__((aligned(4)));
1206
1207	#define HVX_VectorPred HEXAGON_VecPred128
1208	#define HVX_Vector HEXAGON_Vect1024
1209	#define HVX_VectorPair HEXAGON_Vect2048
1210	#define HVX_UVector HEXAGON_UVect1024
1211	#define HVX_UVectorPair HEXAGON_UVect2048
1212	#else /* defined __HVX__ && (__HVX_LENGTH__ == 128) */
1213	#if defined __HVX__ && (__HVX_LENGTH__ == 64)
1214	typedef long HEXAGON_VecPred64 __attribute__((__vector_size__(64)))
1215	__attribute__((aligned(64)));
1216
1217	typedef long HEXAGON_Vect512 __attribute__((__vector_size__(64)))
1218	__attribute__((aligned(64)));
1219
1220	typedef long HEXAGON_Vect1024 __attribute__((__vector_size__(128)))
1221	__attribute__((aligned(128)));
1222
1223	typedef long HEXAGON_UVect512 __attribute__((__vector_size__(64)))
1224	__attribute__((aligned(4)));
1225
1226	typedef long HEXAGON_UVect1024 __attribute__((__vector_size__(128)))
1227	__attribute__((aligned(4)));
1228
1229	#define HVX_VectorPred HEXAGON_VecPred64
1230	#define HVX_Vector HEXAGON_Vect512
1231	#define HVX_VectorPair HEXAGON_Vect1024
1232	#define HVX_UVector HEXAGON_UVect512
1233	#define HVX_UVectorPair HEXAGON_UVect1024
1234	#endif /* defined __HVX__ && (__HVX_LENGTH__ == 64) */
1235	#endif /* defined __HVX__ && (__HVX_LENGTH__ == 128) */
1236	#endif /* __HVX_ARCH__ >= 65 */
1237
1238	/* Predicates */
1239
1240	typedef int HEXAGON_Pred;
1241
1242	/***
1243	*** backward compatibility aliases
1244	***/
1245
1246	/* Old names */
1247	#define Q6Vect Q6Vect64
1248	#define Q6V_GET_D Q6V64_GET_D
1249	#define Q6V_GET_UD Q6V64_GET_UD
1250	#define Q6V_GET_W0 Q6V64_GET_W0
1251	#define Q6V_GET_W1 Q6V64_GET_W1
1252	#define Q6V_GET_UW0 Q6V64_GET_UW0
1253	#define Q6V_GET_UW1 Q6V64_GET_UW1
1254	#define Q6V_GET_H0 Q6V64_GET_H0
1255	#define Q6V_GET_H1 Q6V64_GET_H1
1256	#define Q6V_GET_H2 Q6V64_GET_H2
1257	#define Q6V_GET_H3 Q6V64_GET_H3
1258	#define Q6V_GET_UH0 Q6V64_GET_UH0
1259	#define Q6V_GET_UH1 Q6V64_GET_UH1
1260	#define Q6V_GET_UH2 Q6V64_GET_UH2
1261	#define Q6V_GET_UH3 Q6V64_GET_UH3
1262	#define Q6V_GET_B0 Q6V64_GET_B0
1263	#define Q6V_GET_B1 Q6V64_GET_B1
1264	#define Q6V_GET_B2 Q6V64_GET_B2
1265	#define Q6V_GET_B3 Q6V64_GET_B3
1266	#define Q6V_GET_B4 Q6V64_GET_B4
1267	#define Q6V_GET_B5 Q6V64_GET_B5
1268	#define Q6V_GET_B6 Q6V64_GET_B6
1269	#define Q6V_GET_B7 Q6V64_GET_B7
1270	#define Q6V_GET_UB0 Q6V64_GET_UB0
1271	#define Q6V_GET_UB1 Q6V64_GET_UB1
1272	#define Q6V_GET_UB2 Q6V64_GET_UB2
1273	#define Q6V_GET_UB3 Q6V64_GET_UB3
1274	#define Q6V_GET_UB4 Q6V64_GET_UB4
1275	#define Q6V_GET_UB5 Q6V64_GET_UB5
1276	#define Q6V_GET_UB6 Q6V64_GET_UB6
1277	#define Q6V_GET_UB7 Q6V64_GET_UB7
1278	#define Q6V_PUT_D Q6V64_PUT_D
1279	#define Q6V_PUT_W0 Q6V64_PUT_W0
1280	#define Q6V_PUT_W1 Q6V64_PUT_W1
1281	#define Q6V_PUT_H0 Q6V64_PUT_H0
1282	#define Q6V_PUT_H1 Q6V64_PUT_H1
1283	#define Q6V_PUT_H2 Q6V64_PUT_H2
1284	#define Q6V_PUT_H3 Q6V64_PUT_H3
1285	#define Q6V_PUT_B0 Q6V64_PUT_B0
1286	#define Q6V_PUT_B1 Q6V64_PUT_B1
1287	#define Q6V_PUT_B2 Q6V64_PUT_B2
1288	#define Q6V_PUT_B3 Q6V64_PUT_B3
1289	#define Q6V_PUT_B4 Q6V64_PUT_B4
1290	#define Q6V_PUT_B5 Q6V64_PUT_B5
1291	#define Q6V_PUT_B6 Q6V64_PUT_B6
1292	#define Q6V_PUT_B7 Q6V64_PUT_B7
1293	#define Q6V_CREATE_D Q6V64_CREATE_D
1294	#define Q6V_CREATE_W Q6V64_CREATE_W
1295	#define Q6V_CREATE_H Q6V64_CREATE_H
1296	#define Q6V_CREATE_B Q6V64_CREATE_B
1297
1298	#ifdef __cplusplus
1299	#define Q6VectC Q6Vect64C
1300	#endif /* __cplusplus */
1301
1302	/* 64 Bit Vectors */
1303
1304	typedef long long __attribute__((__may_alias__)) Q6Vect64;
1305
1306	/* Extract doubleword macros */
1307
1308	#define Q6V64_GET_D(v) (v)
1309	#define Q6V64_GET_UD(v) ((unsigned long long)(v))
1310
1311	/* Extract word macros */
1312
1313	#define Q6V64_GET_W0(v) \
1314	__extension__({ \
1315	union { \
1316	long long d; \
1317	int w[2]; \
1318	} _Q6V64_internal_union; \
1319	_Q6V64_internal_union.d = (v); \
1320	_Q6V64_internal_union.w[0]; \
1321	})
1322	#define Q6V64_GET_W1(v) \
1323	__extension__({ \
1324	union { \
1325	long long d; \
1326	int w[2]; \
1327	} _Q6V64_internal_union; \
1328	_Q6V64_internal_union.d = (v); \
1329	_Q6V64_internal_union.w[1]; \
1330	})
1331	#define Q6V64_GET_UW0(v) \
1332	__extension__({ \
1333	union { \
1334	long long d; \
1335	unsigned int uw[2]; \
1336	} _Q6V64_internal_union; \
1337	_Q6V64_internal_union.d = (v); \
1338	_Q6V64_internal_union.uw[0]; \
1339	})
1340	#define Q6V64_GET_UW1(v) \
1341	__extension__({ \
1342	union { \
1343	long long d; \
1344	unsigned int uw[2]; \
1345	} _Q6V64_internal_union; \
1346	_Q6V64_internal_union.d = (v); \
1347	_Q6V64_internal_union.uw[1]; \
1348	})
1349
1350	/* Extract half word macros */
1351
1352	#define Q6V64_GET_H0(v) \
1353	__extension__({ \
1354	union { \
1355	long long d; \
1356	short h[4]; \
1357	} _Q6V64_internal_union; \
1358	_Q6V64_internal_union.d = (v); \
1359	_Q6V64_internal_union.h[0]; \
1360	})
1361	#define Q6V64_GET_H1(v) \
1362	__extension__({ \
1363	union { \
1364	long long d; \
1365	short h[4]; \
1366	} _Q6V64_internal_union; \
1367	_Q6V64_internal_union.d = (v); \
1368	_Q6V64_internal_union.h[1]; \
1369	})
1370	#define Q6V64_GET_H2(v) \
1371	__extension__({ \
1372	union { \
1373	long long d; \
1374	short h[4]; \
1375	} _Q6V64_internal_union; \
1376	_Q6V64_internal_union.d = (v); \
1377	_Q6V64_internal_union.h[2]; \
1378	})
1379	#define Q6V64_GET_H3(v) \
1380	__extension__({ \
1381	union { \
1382	long long d; \
1383	short h[4]; \
1384	} _Q6V64_internal_union; \
1385	_Q6V64_internal_union.d = (v); \
1386	_Q6V64_internal_union.h[3]; \
1387	})
1388	#define Q6V64_GET_UH0(v) \
1389	__extension__({ \
1390	union { \
1391	long long d; \
1392	unsigned short uh[4]; \
1393	} _Q6V64_internal_union; \
1394	_Q6V64_internal_union.d = (v); \
1395	_Q6V64_internal_union.uh[0]; \
1396	})
1397	#define Q6V64_GET_UH1(v) \
1398	__extension__({ \
1399	union { \
1400	long long d; \
1401	unsigned short uh[4]; \
1402	} _Q6V64_internal_union; \
1403	_Q6V64_internal_union.d = (v); \
1404	_Q6V64_internal_union.uh[1]; \
1405	})
1406	#define Q6V64_GET_UH2(v) \
1407	__extension__({ \
1408	union { \
1409	long long d; \
1410	unsigned short uh[4]; \
1411	} _Q6V64_internal_union; \
1412	_Q6V64_internal_union.d = (v); \
1413	_Q6V64_internal_union.uh[2]; \
1414	})
1415	#define Q6V64_GET_UH3(v) \
1416	__extension__({ \
1417	union { \
1418	long long d; \
1419	unsigned short uh[4]; \
1420	} _Q6V64_internal_union; \
1421	_Q6V64_internal_union.d = (v); \
1422	_Q6V64_internal_union.uh[3]; \
1423	})
1424
1425	/* Extract byte macros */
1426
1427	#define Q6V64_GET_B0(v) \
1428	__extension__({ \
1429	union { \
1430	long long d; \
1431	signed char b[8]; \
1432	} _Q6V64_internal_union; \
1433	_Q6V64_internal_union.d = (v); \
1434	_Q6V64_internal_union.b[0]; \
1435	})
1436	#define Q6V64_GET_B1(v) \
1437	__extension__({ \
1438	union { \
1439	long long d; \
1440	signed char b[8]; \
1441	} _Q6V64_internal_union; \
1442	_Q6V64_internal_union.d = (v); \
1443	_Q6V64_internal_union.b[1]; \
1444	})
1445	#define Q6V64_GET_B2(v) \
1446	__extension__({ \
1447	union { \
1448	long long d; \
1449	signed char b[8]; \
1450	} _Q6V64_internal_union; \
1451	_Q6V64_internal_union.d = (v); \
1452	_Q6V64_internal_union.b[2]; \
1453	})
1454	#define Q6V64_GET_B3(v) \
1455	__extension__({ \
1456	union { \
1457	long long d; \
1458	signed char b[8]; \
1459	} _Q6V64_internal_union; \
1460	_Q6V64_internal_union.d = (v); \
1461	_Q6V64_internal_union.b[3]; \
1462	})
1463	#define Q6V64_GET_B4(v) \
1464	__extension__({ \
1465	union { \
1466	long long d; \
1467	signed char b[8]; \
1468	} _Q6V64_internal_union; \
1469	_Q6V64_internal_union.d = (v); \
1470	_Q6V64_internal_union.b[4]; \
1471	})
1472	#define Q6V64_GET_B5(v) \
1473	__extension__({ \
1474	union { \
1475	long long d; \
1476	signed char b[8]; \
1477	} _Q6V64_internal_union; \
1478	_Q6V64_internal_union.d = (v); \
1479	_Q6V64_internal_union.b[5]; \
1480	})
1481	#define Q6V64_GET_B6(v) \
1482	__extension__({ \
1483	union { \
1484	long long d; \
1485	signed char b[8]; \
1486	} _Q6V64_internal_union; \
1487	_Q6V64_internal_union.d = (v); \
1488	_Q6V64_internal_union.b[6]; \
1489	})
1490	#define Q6V64_GET_B7(v) \
1491	__extension__({ \
1492	union { \
1493	long long d; \
1494	signed char b[8]; \
1495	} _Q6V64_internal_union; \
1496	_Q6V64_internal_union.d = (v); \
1497	_Q6V64_internal_union.b[7]; \
1498	})
1499	#define Q6V64_GET_UB0(v) \
1500	__extension__({ \
1501	union { \
1502	long long d; \
1503	unsigned char ub[8]; \
1504	} _Q6V64_internal_union; \
1505	_Q6V64_internal_union.d = (v); \
1506	_Q6V64_internal_union.ub[0]; \
1507	})
1508	#define Q6V64_GET_UB1(v) \
1509	__extension__({ \
1510	union { \
1511	long long d; \
1512	unsigned char ub[8]; \
1513	} _Q6V64_internal_union; \
1514	_Q6V64_internal_union.d = (v); \
1515	_Q6V64_internal_union.ub[1]; \
1516	})
1517	#define Q6V64_GET_UB2(v) \
1518	__extension__({ \
1519	union { \
1520	long long d; \
1521	unsigned char ub[8]; \
1522	} _Q6V64_internal_union; \
1523	_Q6V64_internal_union.d = (v); \
1524	_Q6V64_internal_union.ub[2]; \
1525	})
1526	#define Q6V64_GET_UB3(v) \
1527	__extension__({ \
1528	union { \
1529	long long d; \
1530	unsigned char ub[8]; \
1531	} _Q6V64_internal_union; \
1532	_Q6V64_internal_union.d = (v); \
1533	_Q6V64_internal_union.ub[3]; \
1534	})
1535	#define Q6V64_GET_UB4(v) \
1536	__extension__({ \
1537	union { \
1538	long long d; \
1539	unsigned char ub[8]; \
1540	} _Q6V64_internal_union; \
1541	_Q6V64_internal_union.d = (v); \
1542	_Q6V64_internal_union.ub[4]; \
1543	})
1544	#define Q6V64_GET_UB5(v) \
1545	__extension__({ \
1546	union { \
1547	long long d; \
1548	unsigned char ub[8]; \
1549	} _Q6V64_internal_union; \
1550	_Q6V64_internal_union.d = (v); \
1551	_Q6V64_internal_union.ub[5]; \
1552	})
1553	#define Q6V64_GET_UB6(v) \
1554	__extension__({ \
1555	union { \
1556	long long d; \
1557	unsigned char ub[8]; \
1558	} _Q6V64_internal_union; \
1559	_Q6V64_internal_union.d = (v); \
1560	_Q6V64_internal_union.ub[6]; \
1561	})
1562	#define Q6V64_GET_UB7(v) \
1563	__extension__({ \
1564	union { \
1565	long long d; \
1566	unsigned char ub[8]; \
1567	} _Q6V64_internal_union; \
1568	_Q6V64_internal_union.d = (v); \
1569	_Q6V64_internal_union.ub[7]; \
1570	})
1571
1572	/* NOTE: All set macros return a Q6Vect64 type */
1573
1574	/* Set doubleword macro */
1575
1576	#define Q6V64_PUT_D(v, new) (new)
1577
1578	/* Set word macros */
1579
1580	#ifdef __qdsp6__
1581
1582	#define Q6V64_PUT_W0(v, new) \
1583	__extension__({ \
1584	union { \
1585	long long d; \
1586	int w[2]; \
1587	} _Q6V64_internal_union; \
1588	_Q6V64_internal_union.d = (v); \
1589	_Q6V64_internal_union.w[0] = (new); \
1590	_Q6V64_internal_union.d; \
1591	})
1592	#define Q6V64_PUT_W1(v, new) \
1593	__extension__({ \
1594	union { \
1595	long long d; \
1596	int w[2]; \
1597	} _Q6V64_internal_union; \
1598	_Q6V64_internal_union.d = (v); \
1599	_Q6V64_internal_union.w[1] = (new); \
1600	_Q6V64_internal_union.d; \
1601	})
1602
1603	#else /* !__qdsp6__ */
1604
1605	#define Q6V64_PUT_W0(v, new) \
1606	(((v) & 0xffffffff00000000LL) | ((Q6Vect64)((unsigned int)(new))))
1607	#define Q6V64_PUT_W1(v, new) \
1608	(((v) & 0x00000000ffffffffLL) | (((Q6Vect64)(new)) << 32LL))
1609
1610	#endif /* !__qdsp6__ */
1611
1612	/* Set half word macros */
1613
1614	#ifdef __qdsp6__
1615
1616	#define Q6V64_PUT_H0(v, new) \
1617	__extension__({ \
1618	union { \
1619	long long d; \
1620	short h[4]; \
1621	} _Q6V64_internal_union; \
1622	_Q6V64_internal_union.d = (v); \
1623	_Q6V64_internal_union.h[0] = (new); \
1624	_Q6V64_internal_union.d; \
1625	})
1626	#define Q6V64_PUT_H1(v, new) \
1627	__extension__({ \
1628	union { \
1629	long long d; \
1630	short h[4]; \
1631	} _Q6V64_internal_union; \
1632	_Q6V64_internal_union.d = (v); \
1633	_Q6V64_internal_union.h[1] = (new); \
1634	_Q6V64_internal_union.d; \
1635	})
1636	#define Q6V64_PUT_H2(v, new) \
1637	__extension__({ \
1638	union { \
1639	long long d; \
1640	short h[4]; \
1641	} _Q6V64_internal_union; \
1642	_Q6V64_internal_union.d = (v); \
1643	_Q6V64_internal_union.h[2] = (new); \
1644	_Q6V64_internal_union.d; \
1645	})
1646	#define Q6V64_PUT_H3(v, new) \
1647	__extension__({ \
1648	union { \
1649	long long d; \
1650	short h[4]; \
1651	} _Q6V64_internal_union; \
1652	_Q6V64_internal_union.d = (v); \
1653	_Q6V64_internal_union.h[3] = (new); \
1654	_Q6V64_internal_union.d; \
1655	})
1656
1657	#else /* !__qdsp6__ */
1658
1659	#define Q6V64_PUT_H0(v, new) \
1660	(((v) & 0xffffffffffff0000LL) | ((Q6Vect64)((unsigned short)(new))))
1661	#define Q6V64_PUT_H1(v, new) \
1662	(((v) & 0xffffffff0000ffffLL) | (((Q6Vect64)((unsigned short)(new))) << 16LL))
1663	#define Q6V64_PUT_H2(v, new) \
1664	(((v) & 0xffff0000ffffffffLL) | (((Q6Vect64)((unsigned short)(new))) << 32LL))
1665	#define Q6V64_PUT_H3(v, new) \
1666	(((v) & 0x0000ffffffffffffLL) | (((Q6Vect64)(new)) << 48LL))
1667
1668	#endif /* !__qdsp6__ */
1669
1670	/* Set byte macros */
1671
1672	#ifdef __qdsp6__
1673
1674	#define Q6V64_PUT_B0(v, new) \
1675	__extension__({ \
1676	union { \
1677	long long d; \
1678	char b[8]; \
1679	} _Q6V64_internal_union; \
1680	_Q6V64_internal_union.d = (v); \
1681	_Q6V64_internal_union.b[0] = (new); \
1682	_Q6V64_internal_union.d; \
1683	})
1684	#define Q6V64_PUT_B1(v, new) \
1685	__extension__({ \
1686	union { \
1687	long long d; \
1688	char b[8]; \
1689	} _Q6V64_internal_union; \
1690	_Q6V64_internal_union.d = (v); \
1691	_Q6V64_internal_union.b[1] = (new); \
1692	_Q6V64_internal_union.d; \
1693	})
1694	#define Q6V64_PUT_B2(v, new) \
1695	__extension__({ \
1696	union { \
1697	long long d; \
1698	char b[8]; \
1699	} _Q6V64_internal_union; \
1700	_Q6V64_internal_union.d = (v); \
1701	_Q6V64_internal_union.b[2] = (new); \
1702	_Q6V64_internal_union.d; \
1703	})
1704	#define Q6V64_PUT_B3(v, new) \
1705	__extension__({ \
1706	union { \
1707	long long d; \
1708	char b[8]; \
1709	} _Q6V64_internal_union; \
1710	_Q6V64_internal_union.d = (v); \
1711	_Q6V64_internal_union.b[3] = (new); \
1712	_Q6V64_internal_union.d; \
1713	})
1714	#define Q6V64_PUT_B4(v, new) \
1715	__extension__({ \
1716	union { \
1717	long long d; \
1718	char b[8]; \
1719	} _Q6V64_internal_union; \
1720	_Q6V64_internal_union.d = (v); \
1721	_Q6V64_internal_union.b[4] = (new); \
1722	_Q6V64_internal_union.d; \
1723	})
1724	#define Q6V64_PUT_B5(v, new) \
1725	__extension__({ \
1726	union { \
1727	long long d; \
1728	char b[8]; \
1729	} _Q6V64_internal_union; \
1730	_Q6V64_internal_union.d = (v); \
1731	_Q6V64_internal_union.b[5] = (new); \
1732	_Q6V64_internal_union.d; \
1733	})
1734	#define Q6V64_PUT_B6(v, new) \
1735	__extension__({ \
1736	union { \
1737	long long d; \
1738	char b[8]; \
1739	} _Q6V64_internal_union; \
1740	_Q6V64_internal_union.d = (v); \
1741	_Q6V64_internal_union.b[6] = (new); \
1742	_Q6V64_internal_union.d; \
1743	})
1744	#define Q6V64_PUT_B7(v, new) \
1745	__extension__({ \
1746	union { \
1747	long long d; \
1748	char b[8]; \
1749	} _Q6V64_internal_union; \
1750	_Q6V64_internal_union.d = (v); \
1751	_Q6V64_internal_union.b[7] = (new); \
1752	_Q6V64_internal_union.d; \
1753	})
1754
1755	#else /* !__qdsp6__ */
1756
1757	#define Q6V64_PUT_B0(v, new) \
1758	(((v) & 0xffffffffffffff00LL) | ((Q6Vect64)((unsigned char)(new))))
1759	#define Q6V64_PUT_B1(v, new) \
1760	(((v) & 0xffffffffffff00ffLL) | (((Q6Vect64)((unsigned char)(new))) << 8LL))
1761	#define Q6V64_PUT_B2(v, new) \
1762	(((v) & 0xffffffffff00ffffLL) | (((Q6Vect64)((unsigned char)(new))) << 16LL))
1763	#define Q6V64_PUT_B3(v, new) \
1764	(((v) & 0xffffffff00ffffffLL) | (((Q6Vect64)((unsigned char)(new))) << 24LL))
1765	#define Q6V64_PUT_B4(v, new) \
1766	(((v) & 0xffffff00ffffffffLL) | (((Q6Vect64)((unsigned char)(new))) << 32LL))
1767	#define Q6V64_PUT_B5(v, new) \
1768	(((v) & 0xffff00ffffffffffLL) | (((Q6Vect64)((unsigned char)(new))) << 40LL))
1769	#define Q6V64_PUT_B6(v, new) \
1770	(((v) & 0xff00ffffffffffffLL) | (((Q6Vect64)((unsigned char)(new))) << 48LL))
1771	#define Q6V64_PUT_B7(v, new) \
1772	(((v) & 0x00ffffffffffffffLL) | (((Q6Vect64)(new)) << 56LL))
1773
1774	#endif /* !__qdsp6__ */
1775
1776	/* NOTE: All create macros return a Q6Vect64 type */
1777
1778	/* Create from a doubleword */
1779
1780	#define Q6V64_CREATE_D(d) (d)
1781
1782	/* Create from words */
1783
1784	#ifdef __qdsp6__
1785
1786	#define Q6V64_CREATE_W(w1, w0) \
1787	__extension__({ \
1788	union { \
1789	long long d; \
1790	int w[2]; \
1791	} _Q6V64_internal_union; \
1792	_Q6V64_internal_union.w[0] = (w0); \
1793	_Q6V64_internal_union.w[1] = (w1); \
1794	_Q6V64_internal_union.d; \
1795	})
1796
1797	#else /* !__qdsp6__ */
1798
1799	#define Q6V64_CREATE_W(w1, w0) \
1800	((((Q6Vect64)(w1)) << 32LL) | ((Q6Vect64)((w0) & 0xffffffff)))
1801
1802	#endif /* !__qdsp6__ */
1803
1804	/* Create from half words */
1805
1806	#ifdef __qdsp6__
1807
1808	#define Q6V64_CREATE_H(h3, h2, h1, h0) \
1809	__extension__({ \
1810	union { \
1811	long long d; \
1812	short h[4]; \
1813	} _Q6V64_internal_union; \
1814	_Q6V64_internal_union.h[0] = (h0); \
1815	_Q6V64_internal_union.h[1] = (h1); \
1816	_Q6V64_internal_union.h[2] = (h2); \
1817	_Q6V64_internal_union.h[3] = (h3); \
1818	_Q6V64_internal_union.d; \
1819	})
1820
1821	#else /* !__qdsp6__ */
1822
1823	#define Q6V64_CREATE_H(h3, h2, h1, h0) \
1824	((((Q6Vect64)(h3)) << 48LL) | (((Q6Vect64)((h2) & 0xffff)) << 32LL) | \
1825	(((Q6Vect64)((h1) & 0xffff)) << 16LL) | ((Q6Vect64)((h0) & 0xffff)))
1826
1827	#endif /* !__qdsp6__ */
1828
1829	/* Create from bytes */
1830
1831	#ifdef __qdsp6__
1832
1833	#define Q6V64_CREATE_B(b7, b6, b5, b4, b3, b2, b1, b0) \
1834	__extension__({ \
1835	union { \
1836	long long d; \
1837	char b[8]; \
1838	} _Q6V64_internal_union; \
1839	_Q6V64_internal_union.b[0] = (b0); \
1840	_Q6V64_internal_union.b[1] = (b1); \
1841	_Q6V64_internal_union.b[2] = (b2); \
1842	_Q6V64_internal_union.b[3] = (b3); \
1843	_Q6V64_internal_union.b[4] = (b4); \
1844	_Q6V64_internal_union.b[5] = (b5); \
1845	_Q6V64_internal_union.b[6] = (b6); \
1846	_Q6V64_internal_union.b[7] = (b7); \
1847	_Q6V64_internal_union.d; \
1848	})
1849
1850	#else /* !__qdsp6__ */
1851
1852	#define Q6V64_CREATE_B(b7, b6, b5, b4, b3, b2, b1, b0) \
1853	((((Q6Vect64)(b7)) << 56LL) | (((Q6Vect64)((b6) & 0xff)) << 48LL) | \
1854	(((Q6Vect64)((b5) & 0xff)) << 40LL) | (((Q6Vect64)((b4) & 0xff)) << 32LL) | \
1855	(((Q6Vect64)((b3) & 0xff)) << 24LL) | (((Q6Vect64)((b2) & 0xff)) << 16LL) | \
1856	(((Q6Vect64)((b1) & 0xff)) << 8LL) | ((Q6Vect64)((b0) & 0xff)))
1857
1858	#endif /* !__qdsp6__ */
1859
1860	#ifdef __cplusplus
1861
1862	class Q6Vect64C {
1863	public:
1864	// Constructors
1865	Q6Vect64C(long long d = 0) : data(d) {};
1866	Q6Vect64C(int w1, int w0) : data(Q6V64_CREATE_W(w1, w0)) {};
1867	Q6Vect64C(short h3, short h2, short h1, short h0)
1868	: data(Q6V64_CREATE_H(h3, h2, h1, h0)) {};
1869	Q6Vect64C(signed char b7, signed char b6, signed char b5, signed char b4,
1870	signed char b3, signed char b2, signed char b1, signed char b0)
1871	: data(Q6V64_CREATE_B(b7, b6, b5, b4, b3, b2, b1, b0)) {};
1872	Q6Vect64C(const Q6Vect64C &v) : data(v.data) {};
1873
1874	Q6Vect64C &operator=(const Q6Vect64C &v) {
1875	data = v.data;
1876	return *this;
1877	};
1878
1879	operator long long() {
1880	return data;
1881	};
1882
1883	// Extract doubleword methods
1884	long long D(void) {
1885	return Q6V64_GET_D(data);
1886	};
1887	unsigned long long UD(void) {
1888	return Q6V64_GET_UD(data);
1889	};
1890
1891	// Extract word methods
1892	int W0(void) {
1893	return Q6V64_GET_W0(data);
1894	};
1895	int W1(void) {
1896	return Q6V64_GET_W1(data);
1897	};
1898	unsigned int UW0(void) {
1899	return Q6V64_GET_UW0(data);
1900	};
1901	unsigned int UW1(void) {
1902	return Q6V64_GET_UW1(data);
1903	};
1904
1905	// Extract half word methods
1906	short H0(void) {
1907	return Q6V64_GET_H0(data);
1908	};
1909	short H1(void) {
1910	return Q6V64_GET_H1(data);
1911	};
1912	short H2(void) {
1913	return Q6V64_GET_H2(data);
1914	};
1915	short H3(void) {
1916	return Q6V64_GET_H3(data);
1917	};
1918	unsigned short UH0(void) {
1919	return Q6V64_GET_UH0(data);
1920	};
1921	unsigned short UH1(void) {
1922	return Q6V64_GET_UH1(data);
1923	};
1924	unsigned short UH2(void) {
1925	return Q6V64_GET_UH2(data);
1926	};
1927	unsigned short UH3(void) {
1928	return Q6V64_GET_UH3(data);
1929	};
1930
1931	// Extract byte methods
1932	signed char b0(void) { return Q6V64_GET_B0(data); };
1933	signed char B0(void) { return b0(); };
1934	signed char B1(void) {
1935	return Q6V64_GET_B1(data);
1936	};
1937	signed char B2(void) {
1938	return Q6V64_GET_B2(data);
1939	};
1940	signed char B3(void) {
1941	return Q6V64_GET_B3(data);
1942	};
1943	signed char B4(void) {
1944	return Q6V64_GET_B4(data);
1945	};
1946	signed char B5(void) {
1947	return Q6V64_GET_B5(data);
1948	};
1949	signed char B6(void) {
1950	return Q6V64_GET_B6(data);
1951	};
1952	signed char B7(void) {
1953	return Q6V64_GET_B7(data);
1954	};
1955	unsigned char UB0(void) {
1956	return Q6V64_GET_UB0(data);
1957	};
1958	unsigned char UB1(void) {
1959	return Q6V64_GET_UB1(data);
1960	};
1961	unsigned char UB2(void) {
1962	return Q6V64_GET_UB2(data);
1963	};
1964	unsigned char UB3(void) {
1965	return Q6V64_GET_UB3(data);
1966	};
1967	unsigned char UB4(void) {
1968	return Q6V64_GET_UB4(data);
1969	};
1970	unsigned char UB5(void) {
1971	return Q6V64_GET_UB5(data);
1972	};
1973	unsigned char UB6(void) {
1974	return Q6V64_GET_UB6(data);
1975	};
1976	unsigned char UB7(void) {
1977	return Q6V64_GET_UB7(data);
1978	};
1979
1980	// NOTE: All set methods return a Q6Vect64C type
1981
1982	// Set doubleword method
1983	Q6Vect64C D(long long d) {
1984	return Q6Vect64C(Q6V64_PUT_D(data, d));
1985	};
1986
1987	// Set word methods
1988	Q6Vect64C W0(int w) {
1989	return Q6Vect64C(Q6V64_PUT_W0(data, w));
1990	};
1991	Q6Vect64C W1(int w) {
1992	return Q6Vect64C(Q6V64_PUT_W1(data, w));
1993	};
1994
1995	// Set half word methods
1996	Q6Vect64C H0(short h) {
1997	return Q6Vect64C(Q6V64_PUT_H0(data, h));
1998	};
1999	Q6Vect64C H1(short h) {
2000	return Q6Vect64C(Q6V64_PUT_H1(data, h));
2001	};
2002	Q6Vect64C H2(short h) {
2003	return Q6Vect64C(Q6V64_PUT_H2(data, h));
2004	};
2005	Q6Vect64C H3(short h) {
2006	return Q6Vect64C(Q6V64_PUT_H3(data, h));
2007	};
2008
2009	// Set byte methods
2010	Q6Vect64C b0(signed char b) { return Q6Vect64C(Q6V64_PUT_B0(data, b)); };
2011	Q6Vect64C B0(signed char b) { return b0(b); };
2012	Q6Vect64C B1(signed char b) {
2013	return Q6Vect64C(Q6V64_PUT_B1(data, b));
2014	};
2015	Q6Vect64C B2(signed char b) {
2016	return Q6Vect64C(Q6V64_PUT_B2(data, b));
2017	};
2018	Q6Vect64C B3(signed char b) {
2019	return Q6Vect64C(Q6V64_PUT_B3(data, b));
2020	};
2021	Q6Vect64C B4(signed char b) {
2022	return Q6Vect64C(Q6V64_PUT_B4(data, b));
2023	};
2024	Q6Vect64C B5(signed char b) {
2025	return Q6Vect64C(Q6V64_PUT_B5(data, b));
2026	};
2027	Q6Vect64C B6(signed char b) {
2028	return Q6Vect64C(Q6V64_PUT_B6(data, b));
2029	};
2030	Q6Vect64C B7(signed char b) {
2031	return Q6Vect64C(Q6V64_PUT_B7(data, b));
2032	};
2033
2034	private:
2035	long long data;
2036	};
2037
2038	#endif /* __cplusplus */
2039
2040	/* 32 Bit Vectors */
2041
2042	typedef int Q6Vect32;
2043
2044	/* Extract word macros */
2045
2046	#define Q6V32_GET_W(v) (v)
2047	#define Q6V32_GET_UW(v) ((unsigned int)(v))
2048
2049	/* Extract half word macros */
2050
2051	#define Q6V32_GET_H0(v) \
2052	__extension__({ \
2053	union { \
2054	int w; \
2055	short h[2]; \
2056	} _Q6V32_internal_union; \
2057	_Q6V32_internal_union.w = (v); \
2058	_Q6V32_internal_union.h[0]; \
2059	})
2060	#define Q6V32_GET_H1(v) \
2061	__extension__({ \
2062	union { \
2063	int w; \
2064	short h[2]; \
2065	} _Q6V32_internal_union; \
2066	_Q6V32_internal_union.w = (v); \
2067	_Q6V32_internal_union.h[1]; \
2068	})
2069	#define Q6V32_GET_UH0(v) \
2070	__extension__({ \
2071	union { \
2072	int w; \
2073	unsigned short uh[2]; \
2074	} _Q6V32_internal_union; \
2075	_Q6V32_internal_union.w = (v); \
2076	_Q6V32_internal_union.uh[0]; \
2077	})
2078	#define Q6V32_GET_UH1(v) \
2079	__extension__({ \
2080	union { \
2081	int w; \
2082	unsigned short uh[2]; \
2083	} _Q6V32_internal_union; \
2084	_Q6V32_internal_union.w = (v); \
2085	_Q6V32_internal_union.uh[1]; \
2086	})
2087
2088	/* Extract byte macros */
2089
2090	#define Q6V32_GET_B0(v) \
2091	__extension__({ \
2092	union { \
2093	int w; \
2094	signed char b[4]; \
2095	} _Q6V32_internal_union; \
2096	_Q6V32_internal_union.w = (v); \
2097	_Q6V32_internal_union.b[0]; \
2098	})
2099	#define Q6V32_GET_B1(v) \
2100	__extension__({ \
2101	union { \
2102	int w; \
2103	signed char b[4]; \
2104	} _Q6V32_internal_union; \
2105	_Q6V32_internal_union.w = (v); \
2106	_Q6V32_internal_union.b[1]; \
2107	})
2108	#define Q6V32_GET_B2(v) \
2109	__extension__({ \
2110	union { \
2111	int w; \
2112	signed char b[4]; \
2113	} _Q6V32_internal_union; \
2114	_Q6V32_internal_union.w = (v); \
2115	_Q6V32_internal_union.b[2]; \
2116	})
2117	#define Q6V32_GET_B3(v) \
2118	__extension__({ \
2119	union { \
2120	int w; \
2121	signed char b[4]; \
2122	} _Q6V32_internal_union; \
2123	_Q6V32_internal_union.w = (v); \
2124	_Q6V32_internal_union.b[3]; \
2125	})
2126	#define Q6V32_GET_UB0(v) \
2127	__extension__({ \
2128	union { \
2129	int w; \
2130	unsigned char ub[4]; \
2131	} _Q6V32_internal_union; \
2132	_Q6V32_internal_union.w = (v); \
2133	_Q6V32_internal_union.ub[0]; \
2134	})
2135	#define Q6V32_GET_UB1(v) \
2136	__extension__({ \
2137	union { \
2138	int w; \
2139	unsigned char ub[4]; \
2140	} _Q6V32_internal_union; \
2141	_Q6V32_internal_union.w = (v); \
2142	_Q6V32_internal_union.ub[1]; \
2143	})
2144	#define Q6V32_GET_UB2(v) \
2145	__extension__({ \
2146	union { \
2147	int w; \
2148	unsigned char ub[4]; \
2149	} _Q6V32_internal_union; \
2150	_Q6V32_internal_union.w = (v); \
2151	_Q6V32_internal_union.ub[2]; \
2152	})
2153	#define Q6V32_GET_UB3(v) \
2154	__extension__({ \
2155	union { \
2156	int w; \
2157	unsigned char ub[4]; \
2158	} _Q6V32_internal_union; \
2159	_Q6V32_internal_union.w = (v); \
2160	_Q6V32_internal_union.ub[3]; \
2161	})
2162
2163	/* NOTE: All set macros return a Q6Vect32 type */
2164
2165	/* Set word macro */
2166
2167	#define Q6V32_PUT_W(v, new) (new)
2168
2169	/* Set half word macros */
2170
2171	#ifdef __qdsp6__
2172
2173	#define Q6V32_PUT_H0(v, new) \
2174	__extension__({ \
2175	union { \
2176	int w; \
2177	short h[2]; \
2178	} _Q6V32_internal_union; \
2179	_Q6V32_internal_union.w = (v); \
2180	_Q6V32_internal_union.h[0] = (new); \
2181	_Q6V32_internal_union.w; \
2182	})
2183	#define Q6V32_PUT_H1(v, new) \
2184	__extension__({ \
2185	union { \
2186	int w; \
2187	short h[2]; \
2188	} _Q6V32_internal_union; \
2189	_Q6V32_internal_union.w = (v); \
2190	_Q6V32_internal_union.h[1] = (new); \
2191	_Q6V32_internal_union.w; \
2192	})
2193
2194	#else /* !__qdsp6__ */
2195
2196	#define Q6V32_PUT_H0(v, new) \
2197	(((v) & 0xffff0000) | ((Q6Vect32)((unsigned short)(new))))
2198	#define Q6V32_PUT_H1(v, new) (((v) & 0x0000ffff) | (((Q6Vect32)(new)) << 16))
2199
2200	#endif /* !__qdsp6__ */
2201
2202	/* Set byte macros */
2203
2204	#ifdef __qdsp6__
2205
2206	#define Q6V32_PUT_B0(v, new) \
2207	__extension__({ \
2208	union { \
2209	int w; \
2210	char b[4]; \
2211	} _Q6V32_internal_union; \
2212	_Q6V32_internal_union.w = (v); \
2213	_Q6V32_internal_union.b[0] = (new); \
2214	_Q6V32_internal_union.w; \
2215	})
2216	#define Q6V32_PUT_B1(v, new) \
2217	__extension__({ \
2218	union { \
2219	int w; \
2220	char b[4]; \
2221	} _Q6V32_internal_union; \
2222	_Q6V32_internal_union.w = (v); \
2223	_Q6V32_internal_union.b[1] = (new); \
2224	_Q6V32_internal_union.w; \
2225	})
2226	#define Q6V32_PUT_B2(v, new) \
2227	__extension__({ \
2228	union { \
2229	int w; \
2230	char b[4]; \
2231	} _Q6V32_internal_union; \
2232	_Q6V32_internal_union.w = (v); \
2233	_Q6V32_internal_union.b[2] = (new); \
2234	_Q6V32_internal_union.w; \
2235	})
2236	#define Q6V32_PUT_B3(v, new) \
2237	__extension__({ \
2238	union { \
2239	int w; \
2240	char b[4]; \
2241	} _Q6V32_internal_union; \
2242	_Q6V32_internal_union.w = (v); \
2243	_Q6V32_internal_union.b[3] = (new); \
2244	_Q6V32_internal_union.w; \
2245	})
2246
2247	#else /* !__qdsp6__ */
2248
2249	#define Q6V32_PUT_B0(v, new) \
2250	(((v) & 0xffffff00) | ((Q6Vect32)((unsigned char)(new))))
2251	#define Q6V32_PUT_B1(v, new) \
2252	(((v) & 0xffff00ff) | (((Q6Vect32)((unsigned char)(new))) << 8))
2253	#define Q6V32_PUT_B2(v, new) \
2254	(((v) & 0xff00ffff) | (((Q6Vect32)((unsigned char)(new))) << 16))
2255	#define Q6V32_PUT_B3(v, new) (((v) & 0x00ffffff) | (((Q6Vect32)(new)) << 24))
2256
2257	#endif /* !__qdsp6__ */
2258
2259	/* NOTE: All create macros return a Q6Vect32 type */
2260
2261	/* Create from a word */
2262
2263	#define Q6V32_CREATE_W(w) (w)
2264
2265	/* Create from half words */
2266
2267	#ifdef __qdsp6__
2268
2269	#define Q6V32_CREATE_H(h1, h0) \
2270	__extension__({ \
2271	union { \
2272	long long d; \
2273	short h[2]; \
2274	} _Q6V32_internal_union; \
2275	_Q6V32_internal_union.h[0] = (h0); \
2276	_Q6V32_internal_union.h[1] = (h1); \
2277	_Q6V32_internal_union.d; \
2278	})
2279
2280	#else /* !__qdsp6__ */
2281
2282	#define Q6V32_CREATE_H(h1, h0) \
2283	((((Q6Vect32)(h1)) << 16) | ((Q6Vect32)((h0) & 0xffff)))
2284
2285	#endif /* !__qdsp6__ */
2286
2287	/* Create from bytes */
2288	#ifdef __qdsp6__
2289
2290	#define Q6V32_CREATE_B(b3, b2, b1, b0) \
2291	__extension__({ \
2292	union { \
2293	long long d; \
2294	char b[4]; \
2295	} _Q6V32_internal_union; \
2296	_Q6V32_internal_union.b[0] = (b0); \
2297	_Q6V32_internal_union.b[1] = (b1); \
2298	_Q6V32_internal_union.b[2] = (b2); \
2299	_Q6V32_internal_union.b[3] = (b3); \
2300	_Q6V32_internal_union.d; \
2301	})
2302
2303	#else /* !__qdsp6__ */
2304
2305	#define Q6V32_CREATE_B(b3, b2, b1, b0) \
2306	((((Q6Vect32)(b3)) << 24) | (((Q6Vect32)((b2) & 0xff)) << 16) | \
2307	(((Q6Vect32)((b1) & 0xff)) << 8) | ((Q6Vect32)((b0) & 0xff)))
2308
2309	#endif /* !__qdsp6__ */
2310
2311	#ifdef __cplusplus
2312
2313	class Q6Vect32C {
2314	public:
2315	// Constructors
2316	Q6Vect32C(int w = 0) : data(w) {};
2317	Q6Vect32C(short h1, short h0) : data(Q6V32_CREATE_H(h1, h0)) {};
2318	Q6Vect32C(signed char b3, signed char b2, signed char b1, signed char b0)
2319	: data(Q6V32_CREATE_B(b3, b2, b1, b0)) {};
2320	Q6Vect32C(const Q6Vect32C &v) : data(v.data) {};
2321
2322	Q6Vect32C &operator=(const Q6Vect32C &v) {
2323	data = v.data;
2324	return *this;
2325	};
2326
2327	operator int() {
2328	return data;
2329	};
2330
2331	// Extract word methods
2332	int W(void) {
2333	return Q6V32_GET_W(data);
2334	};
2335	unsigned int UW(void) {
2336	return Q6V32_GET_UW(data);
2337	};
2338
2339	// Extract half word methods
2340	short H0(void) {
2341	return Q6V32_GET_H0(data);
2342	};
2343	short H1(void) {
2344	return Q6V32_GET_H1(data);
2345	};
2346	unsigned short UH0(void) {
2347	return Q6V32_GET_UH0(data);
2348	};
2349	unsigned short UH1(void) {
2350	return Q6V32_GET_UH1(data);
2351	};
2352
2353	// Extract byte methods
2354	signed char b0(void) { return Q6V32_GET_B0(data); };
2355	signed char B0(void) { return b0(); };
2356	signed char B1(void) {
2357	return Q6V32_GET_B1(data);
2358	};
2359	signed char B2(void) {
2360	return Q6V32_GET_B2(data);
2361	};
2362	signed char B3(void) {
2363	return Q6V32_GET_B3(data);
2364	};
2365	unsigned char UB0(void) {
2366	return Q6V32_GET_UB0(data);
2367	};
2368	unsigned char UB1(void) {
2369	return Q6V32_GET_UB1(data);
2370	};
2371	unsigned char UB2(void) {
2372	return Q6V32_GET_UB2(data);
2373	};
2374	unsigned char UB3(void) {
2375	return Q6V32_GET_UB3(data);
2376	};
2377
2378	// NOTE: All set methods return a Q6Vect32C type
2379
2380	// Set word method
2381	Q6Vect32C W(int w) {
2382	return Q6Vect32C(Q6V32_PUT_W(data, w));
2383	};
2384
2385	// Set half word methods
2386	Q6Vect32C H0(short h) {
2387	return Q6Vect32C(Q6V32_PUT_H0(data, h));
2388	};
2389	Q6Vect32C H1(short h) {
2390	return Q6Vect32C(Q6V32_PUT_H1(data, h));
2391	};
2392
2393	// Set byte methods
2394	Q6Vect32C b0(signed char b) { return Q6Vect32C(Q6V32_PUT_B0(data, b)); };
2395	Q6Vect32C B0(signed char b) { return b0(b); };
2396	Q6Vect32C B1(signed char b) {
2397	return Q6Vect32C(Q6V32_PUT_B1(data, b));
2398	};
2399	Q6Vect32C B2(signed char b) {
2400	return Q6Vect32C(Q6V32_PUT_B2(data, b));
2401	};
2402	Q6Vect32C B3(signed char b) {
2403	return Q6Vect32C(Q6V32_PUT_B3(data, b));
2404	};
2405
2406	private:
2407	int data;
2408	};
2409
2410	#endif /* __cplusplus */
2411
2412	// V65 Vector types
2413	#if __HVX_ARCH__ >= 65
2414	#if defined __HVX__ && (__HVX_LENGTH__ == 128)
2415	typedef long Q6VecPred128 __attribute__((__vector_size__(128)))
2416	__attribute__((aligned(128)));
2417
2418	typedef long Q6Vect1024 __attribute__((__vector_size__(128)))
2419	__attribute__((aligned(128)));
2420
2421	typedef long Q6Vect2048 __attribute__((__vector_size__(256)))
2422	__attribute__((aligned(256)));
2423
2424	#else /* defined __HVX__ && (__HVX_LENGTH__ == 128) */
2425	#if defined __HVX__ && (__HVX_LENGTH__ == 64)
2426	typedef long Q6VecPred64 __attribute__((__vector_size__(64)))
2427	__attribute__((aligned(64)));
2428
2429	typedef long Q6Vect512 __attribute__((__vector_size__(64)))
2430	__attribute__((aligned(64)));
2431
2432	typedef long Q6Vect1024 __attribute__((__vector_size__(128)))
2433	__attribute__((aligned(128)));
2434
2435	#endif /* defined __HVX__ && (__HVX_LENGTH__ == 64) */
2436	#endif /* defined __HVX__ && (__HVX_LENGTH__ == 128) */
2437	#endif /* __HVX_ARCH__ >= 65 */
2438
2439	/* Predicates */
2440
2441	typedef int Q6Pred;
2442
2443
2444	#ifdef __HVX__
2445
2446	// Extract HVX VectorPair macro.
2447	#define HEXAGON_HVX_GET_W(v) (v)
2448
2449	// Extract HVX Vector macros.
2450	#define HEXAGON_HVX_GET_V0(v) \
2451	__extension__({ \
2452	union { \
2453	HVX_VectorPair W; \
2454	HVX_Vector V[2]; \
2455	} _HEXAGON_HVX_internal_union; \
2456	_HEXAGON_HVX_internal_union.W = (v); \
2457	_HEXAGON_HVX_internal_union.V[0]; \
2458	})
2459	#define HEXAGON_HVX_GET_V1(v) \
2460	__extension__({ \
2461	union { \
2462	HVX_VectorPair W; \
2463	HVX_Vector V[2]; \
2464	} _HEXAGON_HVX_internal_union; \
2465	_HEXAGON_HVX_internal_union.W = (v); \
2466	_HEXAGON_HVX_internal_union.V[1]; \
2467	})
2468	#define HEXAGON_HVX_GET_P(v) \
2469	__extension__({ \
2470	union { \
2471	HVX_VectorPair W; \
2472	HVX_VectorPred P[2]; \
2473	} _HEXAGON_HVX_internal_union; \
2474	_HEXAGON_HVX_internal_union.W = (v); \
2475	_HEXAGON_HVX_internal_union.P[0]; \
2476	})
2477
2478	// Set HVX VectorPair macro.
2479	#define HEXAGON_HVX_PUT_W(v, new) (new)
2480
2481	// Set HVX Vector macros.
2482	#define HEXAGON_HVX_PUT_V0(v, new) \
2483	__extension__({ \
2484	union { \
2485	HVX_VectorPair W; \
2486	HVX_Vector V[2]; \
2487	} _HEXAGON_HVX_internal_union; \
2488	_HEXAGON_HVX_internal_union.W = (v); \
2489	_HEXAGON_HVX_internal_union.V[0] = (new); \
2490	_HEXAGON_HVX_internal_union.W; \
2491	})
2492
2493	#define HEXAGON_HVX_PUT_V1(v, new) \
2494	__extension__({ \
2495	union { \
2496	HVX_VectorPair W; \
2497	HVX_Vector V[2]; \
2498	} _HEXAGON_HVX_internal_union; \
2499	_HEXAGON_HVX_internal_union.W = (v); \
2500	_HEXAGON_HVX_internal_union.V[1] = (new); \
2501	_HEXAGON_HVX_internal_union.W; \
2502	})
2503
2504	#define HEXAGON_HVX_PUT_P(v, new) \
2505	__extension__({ \
2506	union { \
2507	HVX_VectorPair W; \
2508	HVX_VectorPred P[2]; \
2509	} _HEXAGON_HVX_internal_union; \
2510	_HEXAGON_HVX_internal_union.W = (v); \
2511	_HEXAGON_HVX_internal_union.P[0] = (new); \
2512	_HEXAGON_HVX_internal_union.W; \
2513	})
2514
2515
2516	#define HEXAGON_HVX_CREATE_W(v1, v0) \
2517	__extension__({ \
2518	union { \
2519	HVX_VectorPair W; \
2520	HVX_Vector V[2]; \
2521	} _HEXAGON_HVX_internal_union; \
2522	_HEXAGON_HVX_internal_union.V[0] = (v0); \
2523	_HEXAGON_HVX_internal_union.V[1] = (v1); \
2524	_HEXAGON_HVX_internal_union.W; \
2525	})
2526
2527	#ifdef __cplusplus
2528
2529	class HVX_Vect {
2530	public:
2531	// Constructors.
2532	// Default.
2533	HVX_Vect() : data(Q6_W_vcombine_VV(Q6_V_vzero(), Q6_V_vzero())){};
2534
2535	// Custom constructors.
2536	HVX_Vect(HVX_VectorPair W) : data(W){};
2537	HVX_Vect(HVX_Vector v1, HVX_Vector v0) : data(HEXAGON_HVX_CREATE_W(v1, v0)){};
2538
2539	// Copy constructor.
2540	HVX_Vect(const HVX_Vect &W) = default;
2541
2542	// Move constructor.
2543	HVX_Vect(HVX_Vect &&W) = default;
2544
2545	// Assignment operator.
2546	HVX_Vect &operator=(const HVX_Vect &W) = default;
2547
2548	operator HVX_VectorPair() { return data; };
2549
2550	// Extract VectorPair method.
2551	HVX_VectorPair W(void) { return HEXAGON_HVX_GET_W(data); };
2552
2553	// Extract Vector methods.
2554	HVX_Vector V0(void) { return HEXAGON_HVX_GET_V0(data); };
2555	HVX_Vector V1(void) { return HEXAGON_HVX_GET_V1(data); };
2556	HVX_VectorPred P(void) { return HEXAGON_HVX_GET_P(data); };
2557
2558	// NOTE: All set methods return a HVX_Vect type.
2559	// Set HVX VectorPair method.
2560	HVX_Vect W(HVX_VectorPair w) { return HVX_Vect(HEXAGON_HVX_PUT_W(data, w)); };
2561
2562	// Set HVX Vector methods.
2563	HVX_Vect V0(HVX_Vector v) { return HVX_Vect(HEXAGON_HVX_PUT_V0(data, v)); };
2564	HVX_Vect V1(HVX_Vector v) { return HVX_Vect(HEXAGON_HVX_PUT_V1(data, v)); };
2565	HVX_Vect P(HVX_VectorPred p) { return HVX_Vect(HEXAGON_HVX_PUT_P(data, p)); };
2566
2567	private:
2568	HVX_VectorPair data;
2569	};
2570
2571	#endif /* __cplusplus */
2572	#endif /* __HVX__ */
2573
2574	#define HEXAGON_UDMA_DM0_STATUS_IDLE 0x00000000
2575	#define HEXAGON_UDMA_DM0_STATUS_RUN 0x00000001
2576	#define HEXAGON_UDMA_DM0_STATUS_ERROR 0x00000002
2577	#define HEXAGON_UDMA_DESC_DSTATE_INCOMPLETE 0
2578	#define HEXAGON_UDMA_DESC_DSTATE_COMPLETE 1
2579	#define HEXAGON_UDMA_DESC_ORDER_NOORDER 0
2580	#define HEXAGON_UDMA_DESC_ORDER_ORDER 1
2581	#define HEXAGON_UDMA_DESC_BYPASS_OFF 0
2582	#define HEXAGON_UDMA_DESC_BYPASS_ON 1
2583	#define HEXAGON_UDMA_DESC_COMP_NONE 0
2584	#define HEXAGON_UDMA_DESC_COMP_DLBC 1
2585	#define HEXAGON_UDMA_DESC_DESCTYPE_TYPE0 0
2586	#define HEXAGON_UDMA_DESC_DESCTYPE_TYPE1 1
2587
2588	typedef struct hexagon_udma_descriptor_type0_s
2589	{
2590	void *next;
2591	unsigned int length:24;
2592	unsigned int desctype:2;
2593	unsigned int dstcomp:1;
2594	unsigned int srccomp:1;
2595	unsigned int dstbypass:1;
2596	unsigned int srcbypass:1;
2597	unsigned int order:1;
2598	unsigned int dstate:1;
2599	void *src;
2600	void *dst;
2601	} hexagon_udma_descriptor_type0_t;
2602
2603	typedef struct hexagon_udma_descriptor_type1_s
2604	{
2605	void *next;
2606	unsigned int length:24;
2607	unsigned int desctype:2;
2608	unsigned int dstcomp:1;
2609	unsigned int srccomp:1;
2610	unsigned int dstbypass:1;
2611	unsigned int srcbypass:1;
2612	unsigned int order:1;
2613	unsigned int dstate:1;
2614	void *src;
2615	void *dst;
2616	unsigned int allocation:28;
2617	unsigned int padding:4;
2618	unsigned int roiwidth:16;
2619	unsigned int roiheight:16;
2620	unsigned int srcstride:16;
2621	unsigned int dststride:16;
2622	unsigned int srcwidthoffset:16;
2623	unsigned int dstwidthoffset:16;
2624	} hexagon_udma_descriptor_type1_t;
2625
2626	#pragma pop_macro("B0")
2627
2628	#endif /* !HEXAGON_TYPES_H */