source: parabix-LLVM/diff-r209855 @ 4694

Last change on this file since 4694 was 4580, checked in by cameron, 4 years ago

Difference file for LLVM r209855 and parabix-llvm code

File size: 72.2 KB
Line 
1diff -r -b parabix-llvm/include/llvm/CodeGen/ISDOpcodes.h r209855/include/llvm/CodeGen/ISDOpcodes.h
2220,222d219
3<     // llvm.uadd.with.overflow.carryin intrinsics.
4<     UADDE,
5<
6diff -r -b parabix-llvm/include/llvm/CodeGen/MachineValueType.h r209855/include/llvm/CodeGen/MachineValueType.h
738,49c38,43
8<       i1              =  1,
9<       i2              =  2,
10<       i4              =  3,
11<       i8              =  4,
12<       i16             =  5,
13<       i32             =  6,
14<       i64             =  7,
15<       i128            =  8,
16<       i256            =  9,
17<       i512            =  10,
18<       i1024           =  11,
19<
20---
21>       i1             =   1,   // This is a 1 bit integer value
22>       i8             =   2,   // This is an 8 bit integer value
23>       i16            =   3,   // This is a 16 bit integer value
24>       i32            =   4,   // This is a 32 bit integer value
25>       i64            =   5,   // This is a 64 bit integer value
26>       i128           =   6,   // This is a 128 bit integer value
2752c46
28<       LAST_INTEGER_VALUETYPE  = i1024,
29---
30>       LAST_INTEGER_VALUETYPE  = i128,
3154,59c48,53
32<       f16            =   12,   // This is a 16 bit floating point value
33<       f32            =   13,   // This is a 32 bit floating point value
34<       f64            =   14,   // This is a 64 bit floating point value
35<       f80            =  15,   // This is a 80 bit floating point value
36<       f128           =  16,   // This is a 128 bit floating point value
37<       ppcf128        =  17,   // This is a PPC 128-bit floating point value
38---
39>       f16            =   7,   // This is a 16 bit floating point value
40>       f32            =   8,   // This is a 32 bit floating point value
41>       f64            =   9,   // This is a 64 bit floating point value
42>       f80            =  10,   // This is a 80 bit floating point value
43>       f128           =  11,   // This is a 128 bit floating point value
44>       ppcf128        =  12,   // This is a PPC 128-bit floating point value
4564,159c58,109
46<       v1i1            =  18,
47<       v2i1            =  19,
48<       v4i1            =  20,
49<       v8i1            =  21,
50<       v16i1           =  22,
51<       v32i1           =  23,
52<       v64i1           =  24,
53<       v128i1          =  25,
54<       v256i1          =  26,
55<       v512i1          =  27,
56<       v1024i1         =  28,
57<       v1i2            =  29,
58<       v2i2            =  30,
59<       v4i2            =  31,
60<       v8i2            =  32,
61<       v16i2           =  33,
62<       v32i2           =  34,
63<       v64i2           =  35,
64<       v128i2          =  36,
65<       v256i2          =  37,
66<       v512i2          =  38,
67<       v1i4            =  39,
68<       v2i4            =  40,
69<       v4i4            =  41,
70<       v8i4            =  42,
71<       v16i4           =  43,
72<       v32i4           =  44,
73<       v64i4           =  45,
74<       v128i4          =  46,
75<       v256i4          =  47,
76<       v1i8            =  48,
77<       v2i8            =  49,
78<       v4i8            =  50,
79<       v8i8            =  51,
80<       v16i8           =  52,
81<       v32i8           =  53,
82<       v64i8           =  54,
83<       v128i8          =  55,
84<       v1i16           =  56,
85<       v2i16           =  57,
86<       v4i16           =  58,
87<       v8i16           =  59,
88<       v16i16          =  60,
89<       v32i16          =  61,
90<       v64i16          =  62,
91<       v1i32           =  63,
92<       v2i32           =  64,
93<       v4i32           =  65,
94<       v8i32           =  66,
95<       v16i32          =  67,
96<       v32i32          =  68,
97<       v1i64           =  69,
98<       v2i64           =  70,
99<       v4i64           =  71,
100<       v8i64           =  72,
101<       v16i64          =  73,
102<       v1i128          =  74,
103<       v2i128          =  75,
104<       v4i128          =  76,
105<       v8i128          =  77,
106<       v1i256          =  78,
107<       v2i256          =  79,
108<       v4i256          =  80,
109<       v1i512          =  81,
110<       v2i512          =  82,
111<       v1i1024         =  83,
112<
113<
114<       FIRST_INTEGER_VECTOR_VALUETYPE = v1i1,
115<       LAST_INTEGER_VECTOR_VALUETYPE = v1i1024,
116<
117<       v1f16           =  84,
118<       v2f16           =  85,
119<       v4f16           =  86,
120<       v8f16           =  87,
121<       v16f16          =  88,
122<       v32f16          =  89,
123<       v64f16          =  90,
124<       v1f32           =  91,
125<       v2f32           =  92,
126<       v4f32           =  93,
127<       v8f32           =  94,
128<       v16f32          =  95,
129<       v32f32          =  96,
130<       v1f64           =  97,
131<       v2f64           =  98,
132<       v4f64           =  99,
133<       v8f64           =  100,
134<       v16f64          =  101,
135<
136<
137<       FIRST_FP_VECTOR_VALUETYPE = v1f16,
138<       LAST_FP_VECTOR_VALUETYPE = v16f64,
139<
140<       FIRST_VECTOR_VALUETYPE = v1i1,
141<       LAST_VECTOR_VALUETYPE  = v16f64,
142---
143>       v2i1           =  13,   //  2 x i1
144>       v4i1           =  14,   //  4 x i1
145>       v8i1           =  15,   //  8 x i1
146>       v16i1          =  16,   // 16 x i1
147>       v32i1          =  17,   // 32 x i1
148>       v64i1          =  18,   // 64 x i1
149>
150>       v1i8           =  19,   //  1 x i8
151>       v2i8           =  20,   //  2 x i8
152>       v4i8           =  21,   //  4 x i8
153>       v8i8           =  22,   //  8 x i8
154>       v16i8          =  23,   // 16 x i8
155>       v32i8          =  24,   // 32 x i8
156>       v64i8          =  25,   // 64 x i8
157>       v1i16          =  26,   //  1 x i16
158>       v2i16          =  27,   //  2 x i16
159>       v4i16          =  28,   //  4 x i16
160>       v8i16          =  29,   //  8 x i16
161>       v16i16         =  30,   // 16 x i16
162>       v32i16         =  31,   // 32 x i16
163>       v1i32          =  32,   //  1 x i32
164>       v2i32          =  33,   //  2 x i32
165>       v4i32          =  34,   //  4 x i32
166>       v8i32          =  35,   //  8 x i32
167>       v16i32         =  36,   // 16 x i32
168>       v1i64          =  37,   //  1 x i64
169>       v2i64          =  38,   //  2 x i64
170>       v4i64          =  39,   //  4 x i64
171>       v8i64          =  40,   //  8 x i64
172>       v16i64         =  41,   // 16 x i64
173>
174>       FIRST_INTEGER_VECTOR_VALUETYPE = v2i1,
175>       LAST_INTEGER_VECTOR_VALUETYPE = v16i64,
176>
177>       v2f16          =  42,   //  2 x f16
178>       v4f16          =  43,   //  4 x f16
179>       v8f16          =  44,   //  8 x f16
180>       v1f32          =  45,   //  1 x f32
181>       v2f32          =  46,   //  2 x f32
182>       v4f32          =  47,   //  4 x f32
183>       v8f32          =  48,   //  8 x f32
184>       v16f32         =  49,   // 16 x f32
185>       v1f64          =  50,   //  1 x f64
186>       v2f64          =  51,   //  2 x f64
187>       v4f64          =  52,   //  4 x f64
188>       v8f64          =  53,   //  8 x f64
189>
190>       FIRST_FP_VECTOR_VALUETYPE = v2f16,
191>       LAST_FP_VECTOR_VALUETYPE = v8f64,
192>
193>       FIRST_VECTOR_VALUETYPE = v2i1,
194>       LAST_VECTOR_VALUETYPE  = v8f64,
195161c111
196<       x86mmx         =  102,   // This is an X86 MMX value
197---
198>       x86mmx         =  54,   // This is an X86 MMX value
199163c113
200<       Glue           =  103,   // This glues nodes together during pre-RA sched
201---
202>       Glue           =  55,   // This glues nodes together during pre-RA sched
203165c115
204<       isVoid         =  104,   // This has no value
205---
206>       isVoid         =  56,   // This has no value
207167c117
208<       Untyped        =  105,   // This value takes a register, but has
209---
210>       Untyped        =  57,   // This value takes a register, but has
211171c121
212<       LAST_VALUETYPE =  106,   // This always remains at the end of the list.
213---
214>       LAST_VALUETYPE =  58,   // This always remains at the end of the list.
215176c126
216<       MAX_ALLOWED_VALUETYPE = 128,
217---
218>       MAX_ALLOWED_VALUETYPE = 64,
219240,277d189
220<     /// Parabix helper functions here
221<     bool isParabixVector() const {
222<       return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v64i1 ||
223<               SimpleTy == MVT::v64i2 || SimpleTy == MVT::v32i4 ||
224<               SimpleTy == MVT::v128i1);
225<     }
226<
227<     bool isParabixValue() const {
228<       return (SimpleTy == MVT::v1i1 || SimpleTy == MVT::v1i2 || SimpleTy == MVT::v2i2 || SimpleTy == MVT::v1i4 || SimpleTy == MVT::v4i2 || SimpleTy == MVT::v2i4 || SimpleTy == MVT::v8i2 || SimpleTy == MVT::v4i4 || SimpleTy == MVT::v1f16 || SimpleTy == MVT::v16i2 || SimpleTy == MVT::v8i4 || SimpleTy == MVT::v32i2 || SimpleTy == MVT::v16i4 || SimpleTy == MVT::v128i1 || SimpleTy == MVT::v64i2 || SimpleTy == MVT::v32i4 || SimpleTy == MVT::v1i128 || SimpleTy == MVT::v256i1 || SimpleTy == MVT::v128i2 || SimpleTy == MVT::v64i4 || SimpleTy == MVT::v2i128 || SimpleTy == MVT::v1i256 || SimpleTy == MVT::v16f16 || SimpleTy == MVT::v512i1 || SimpleTy == MVT::v256i2 || SimpleTy == MVT::v128i4 || SimpleTy == MVT::v64i8 || SimpleTy == MVT::v4i128 || SimpleTy == MVT::v2i256 || SimpleTy == MVT::v1i512 || SimpleTy == MVT::v32f16 || SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v512i2 || SimpleTy == MVT::v256i4 || SimpleTy == MVT::v128i8 || SimpleTy == MVT::v64i16 || SimpleTy == MVT::v32i32 || SimpleTy == MVT::v8i128 || SimpleTy == MVT::v4i256 || SimpleTy == MVT::v2i512 || SimpleTy == MVT::v1i1024 || SimpleTy == MVT::v64f16 || SimpleTy == MVT::v32f32 || SimpleTy == MVT::v16f64);
229<     }
230<
231<
232<     /// is1BitVector - Return true if this is a 1-bit vector type.
233<     bool is1BitVector() const {
234<     return (SimpleTy == MVT::v1i1);
235<     }
236<
237<     /// is2BitVector - Return true if this is a 2-bit vector type.
238<     bool is2BitVector() const {
239<     return (SimpleTy == MVT::v2i1 ||
240<               SimpleTy == MVT::v1i2);
241<     }
242<
243<     /// is4BitVector - Return true if this is a 4-bit vector type.
244<     bool is4BitVector() const {
245<     return (SimpleTy == MVT::v4i1 ||
246<               SimpleTy == MVT::v2i2 ||
247<               SimpleTy == MVT::v1i4);
248<     }
249<
250<     /// is8BitVector - Return true if this is a 8-bit vector type.
251<     bool is8BitVector() const {
252<     return (SimpleTy == MVT::v8i1 ||
253<               SimpleTy == MVT::v4i2 ||
254<               SimpleTy == MVT::v2i4 ||
255<               SimpleTy == MVT::v1i8);
256<     }
257<
258280,285c192,193
259<     return (SimpleTy == MVT::v16i1 ||
260<               SimpleTy == MVT::v8i2 ||
261<               SimpleTy == MVT::v4i4 ||
262<               SimpleTy == MVT::v2i8 ||
263<               SimpleTy == MVT::v1i16 ||
264<               SimpleTy == MVT::v1f16);
265---
266>       return (SimpleTy == MVT::v2i8  || SimpleTy == MVT::v1i16 ||
267>               SimpleTy == MVT::v16i1);
268290,297c198,199
269<     return (SimpleTy == MVT::v32i1 ||
270<               SimpleTy == MVT::v16i2 ||
271<               SimpleTy == MVT::v8i4 ||
272<               SimpleTy == MVT::v4i8 ||
273<               SimpleTy == MVT::v2i16 ||
274<               SimpleTy == MVT::v1i32 ||
275<               SimpleTy == MVT::v2f16 ||
276<               SimpleTy == MVT::v1f32);
277---
278>       return (SimpleTy == MVT::v4i8  || SimpleTy == MVT::v2i16 ||
279>               SimpleTy == MVT::v1i32);
280302,311c204,206
281<     return (SimpleTy == MVT::v64i1 ||
282<               SimpleTy == MVT::v32i2 ||
283<               SimpleTy == MVT::v16i4 ||
284<               SimpleTy == MVT::v8i8 ||
285<               SimpleTy == MVT::v4i16 ||
286<               SimpleTy == MVT::v2i32 ||
287<               SimpleTy == MVT::v1i64 ||
288<               SimpleTy == MVT::v4f16 ||
289<               SimpleTy == MVT::v2f32 ||
290<               SimpleTy == MVT::v1f64);
291---
292>       return (SimpleTy == MVT::v8i8  || SimpleTy == MVT::v4i16 ||
293>               SimpleTy == MVT::v2i32 || SimpleTy == MVT::v1i64 ||
294>               SimpleTy == MVT::v1f64 || SimpleTy == MVT::v2f32);
295316,326c211,213
296<     return (SimpleTy == MVT::v128i1 ||
297<               SimpleTy == MVT::v64i2 ||
298<               SimpleTy == MVT::v32i4 ||
299<               SimpleTy == MVT::v16i8 ||
300<               SimpleTy == MVT::v8i16 ||
301<               SimpleTy == MVT::v4i32 ||
302<               SimpleTy == MVT::v2i64 ||
303<               SimpleTy == MVT::v1i128 ||
304<               SimpleTy == MVT::v8f16 ||
305<               SimpleTy == MVT::v4f32 ||
306<               SimpleTy == MVT::v2f64);
307---
308>       return (SimpleTy == MVT::v16i8 || SimpleTy == MVT::v8i16 ||
309>               SimpleTy == MVT::v4i32 || SimpleTy == MVT::v2i64 ||
310>               SimpleTy == MVT::v4f32 || SimpleTy == MVT::v2f64);
311331,342c218,220
312<     return (SimpleTy == MVT::v256i1 ||
313<               SimpleTy == MVT::v128i2 ||
314<               SimpleTy == MVT::v64i4 ||
315<               SimpleTy == MVT::v32i8 ||
316<               SimpleTy == MVT::v16i16 ||
317<               SimpleTy == MVT::v8i32 ||
318<               SimpleTy == MVT::v4i64 ||
319<               SimpleTy == MVT::v2i128 ||
320<               SimpleTy == MVT::v1i256 ||
321<               SimpleTy == MVT::v16f16 ||
322<               SimpleTy == MVT::v8f32 ||
323<               SimpleTy == MVT::v4f64);
324---
325>       return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64  ||
326>               SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
327>               SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64);
328347,359c225,227
329<     return (SimpleTy == MVT::v512i1 ||
330<               SimpleTy == MVT::v256i2 ||
331<               SimpleTy == MVT::v128i4 ||
332<               SimpleTy == MVT::v64i8 ||
333<               SimpleTy == MVT::v32i16 ||
334<               SimpleTy == MVT::v16i32 ||
335<               SimpleTy == MVT::v8i64 ||
336<               SimpleTy == MVT::v4i128 ||
337<               SimpleTy == MVT::v2i256 ||
338<               SimpleTy == MVT::v1i512 ||
339<               SimpleTy == MVT::v32f16 ||
340<               SimpleTy == MVT::v16f32 ||
341<               SimpleTy == MVT::v8f64);
342---
343>       return (SimpleTy == MVT::v8f64 || SimpleTy == MVT::v16f32 ||
344>               SimpleTy == MVT::v64i8 || SimpleTy == MVT::v32i16 ||
345>               SimpleTy == MVT::v8i64 || SimpleTy == MVT::v16i32);
346364,377c232
347<     return (SimpleTy == MVT::v1024i1 ||
348<               SimpleTy == MVT::v512i2 ||
349<               SimpleTy == MVT::v256i4 ||
350<               SimpleTy == MVT::v128i8 ||
351<               SimpleTy == MVT::v64i16 ||
352<               SimpleTy == MVT::v32i32 ||
353<               SimpleTy == MVT::v16i64 ||
354<               SimpleTy == MVT::v8i128 ||
355<               SimpleTy == MVT::v4i256 ||
356<               SimpleTy == MVT::v2i512 ||
357<               SimpleTy == MVT::v1i1024 ||
358<               SimpleTy == MVT::v64f16 ||
359<               SimpleTy == MVT::v32f32 ||
360<               SimpleTy == MVT::v16f64);
361---
362>       return (SimpleTy == MVT::v16i64);
363380d234
364<
365410d263
366<
367415,429c268,308
368<               case v1i1:  case v2i1:  case v4i1:  case v8i1:  case v16i1:  case v32i1:  case v64i1:  case v128i1:  case v256i1:  case v512i1:  case v1024i1:  return i1;
369<       case v1i2:  case v2i2:  case v4i2:  case v8i2:  case v16i2:  case v32i2:  case v64i2:  case v128i2:  case v256i2:  case v512i2:  return i2;
370<       case v1i4:  case v2i4:  case v4i4:  case v8i4:  case v16i4:  case v32i4:  case v64i4:  case v128i4:  case v256i4:  return i4;
371<       case v1i8:  case v2i8:  case v4i8:  case v8i8:  case v16i8:  case v32i8:  case v64i8:  case v128i8:  return i8;
372<       case v1f16:  case v2f16:  case v4f16:  case v8f16:  case v16f16:  case v32f16:  case v64f16:  return f16;
373<       case v1i16:  case v2i16:  case v4i16:  case v8i16:  case v16i16:  case v32i16:  case v64i16:  return i16;
374<       case v1f32:  case v2f32:  case v4f32:  case v8f32:  case v16f32:  case v32f32:  return f32;
375<       case v1i32:  case v2i32:  case v4i32:  case v8i32:  case v16i32:  case v32i32:  return i32;
376<       case v1f64:  case v2f64:  case v4f64:  case v8f64:  case v16f64:  return f64;
377<       case v1i64:  case v2i64:  case v4i64:  case v8i64:  case v16i64:  return i64;
378<       case v1i128:  case v2i128:  case v4i128:  case v8i128:  return i128;
379<       case v1i256:  case v2i256:  case v4i256:  return i256;
380<       case v1i512:  case v2i512:  return i512;
381<       case v1i1024:  return i1024;
382<
383---
384>       case v2i1 :
385>       case v4i1 :
386>       case v8i1 :
387>       case v16i1 :
388>       case v32i1 :
389>       case v64i1: return i1;
390>       case v1i8 :
391>       case v2i8 :
392>       case v4i8 :
393>       case v8i8 :
394>       case v16i8:
395>       case v32i8:
396>       case v64i8: return i8;
397>       case v1i16:
398>       case v2i16:
399>       case v4i16:
400>       case v8i16:
401>       case v16i16:
402>       case v32i16: return i16;
403>       case v1i32:
404>       case v2i32:
405>       case v4i32:
406>       case v8i32:
407>       case v16i32: return i32;
408>       case v1i64:
409>       case v2i64:
410>       case v4i64:
411>       case v8i64:
412>       case v16i64: return i64;
413>       case v2f16:
414>       case v4f16:
415>       case v8f16: return f16;
416>       case v1f32:
417>       case v2f32:
418>       case v4f32:
419>       case v8f32:
420>       case v16f32: return f32;
421>       case v1f64:
422>       case v2f64:
423>       case v4f64:
424>       case v8f64: return f64;
425433,435d311
426<
427<
428<
429440,451c316,356
430<             case v1i1: case v1i2: case v1i4: case v1i8: case v1i16: case v1f16: case v1i32: case v1f32: case v1i64: case v1f64: case v1i128: case v1i256: case v1i512: case v1i1024:  return 1;
431<       case v1024i1:  return 1024;
432<       case v128i1: case v128i2: case v128i4: case v128i8:  return 128;
433<       case v16i1: case v16i2: case v16i4: case v16i8: case v16i16: case v16f16: case v16i32: case v16f32: case v16i64: case v16f64:  return 16;
434<       case v2i1: case v2i2: case v2i4: case v2i8: case v2i16: case v2f16: case v2i32: case v2f32: case v2i64: case v2f64: case v2i128: case v2i256: case v2i512:  return 2;
435<       case v256i1: case v256i2: case v256i4:  return 256;
436<       case v32i1: case v32i2: case v32i4: case v32i8: case v32i16: case v32f16: case v32i32: case v32f32:  return 32;
437<       case v4i1: case v4i2: case v4i4: case v4i8: case v4i16: case v4f16: case v4i32: case v4f32: case v4i64: case v4f64: case v4i128: case v4i256:  return 4;
438<       case v512i1: case v512i2:  return 512;
439<       case v64i1: case v64i2: case v64i4: case v64i8: case v64i16: case v64f16:  return 64;
440<       case v8i1: case v8i2: case v8i4: case v8i8: case v8i16: case v8f16: case v8i32: case v8f32: case v8i64: case v8f64: case v8i128:  return 8;
441<
442---
443>       case v32i1:
444>       case v32i8:
445>       case v32i16: return 32;
446>       case v64i1:
447>       case v64i8: return 64;
448>       case v16i1:
449>       case v16i8:
450>       case v16i16:
451>       case v16i32:
452>       case v16i64:
453>       case v16f32: return 16;
454>       case v8i1 :
455>       case v8i8 :
456>       case v8i16:
457>       case v8i32:
458>       case v8i64:
459>       case v8f16:
460>       case v8f32:
461>       case v8f64: return 8;
462>       case v4i1:
463>       case v4i8:
464>       case v4i16:
465>       case v4i32:
466>       case v4i64:
467>       case v4f16:
468>       case v4f32:
469>       case v4f64: return 4;
470>       case v2i1:
471>       case v2i8:
472>       case v2i16:
473>       case v2i32:
474>       case v2i64:
475>       case v2f16:
476>       case v2f32:
477>       case v2f64: return 2;
478>       case v1i8:
479>       case v1i16:
480>       case v1i32:
481>       case v1i64:
482>       case v1f32:
483>       case v1f64: return 1;
484455,457d359
485<
486<
487<
488473,485c375,404
489<             case i1: case v1i1: return 1;
490<       case i2: case v2i1: case v1i2: return 2;
491<       case i4: case v4i1: case v2i2: case v1i4: return 4;
492<       case i8: case v8i1: case v4i2: case v2i4: case v1i8: return 8;
493<       case i16: case f16: case v16i1: case v8i2: case v4i4: case v2i8: case v1i16: case v1f16: return 16;
494<       case i32: case f32: case v32i1: case v16i2: case v8i4: case v4i8: case v2i16: case v1i32: case v2f16: case v1f32: return 32;
495<       case i64: case f64: case v64i1: case v32i2: case v16i4: case v8i8: case v4i16: case v2i32: case v1i64: case v4f16: case v2f32: case v1f64: return 64;
496<       case i128: case v128i1: case v64i2: case v32i4: case v16i8: case v8i16: case v4i32: case v2i64: case v1i128: case v8f16: case v4f32: case v2f64: return 128;
497<       case i256: case v256i1: case v128i2: case v64i4: case v32i8: case v16i16: case v8i32: case v4i64: case v2i128: case v1i256: case v16f16: case v8f32: case v4f64: return 256;
498<       case i512: case v512i1: case v256i2: case v128i4: case v64i8: case v32i16: case v16i32: case v8i64: case v4i128: case v2i256: case v1i512: case v32f16: case v16f32: case v8f64: return 512;
499<       case i1024: case v1024i1: case v512i2: case v256i4: case v128i8: case v64i16: case v32i32: case v16i64: case v8i128: case v4i256: case v2i512: case v1i1024: case v64f16: case v32f32: case v16f64: return 1024;
500<
501<       case x86mmx: return 64;
502---
503>       case i1  :  return 1;
504>       case v2i1:  return 2;
505>       case v4i1:  return 4;
506>       case i8  :
507>       case v1i8:
508>       case v8i1: return 8;
509>       case i16 :
510>       case f16:
511>       case v16i1:
512>       case v2i8:
513>       case v1i16: return 16;
514>       case f32 :
515>       case i32 :
516>       case v32i1:
517>       case v4i8:
518>       case v2i16:
519>       case v2f16:
520>       case v1f32:
521>       case v1i32: return 32;
522>       case x86mmx:
523>       case f64 :
524>       case i64 :
525>       case v64i1:
526>       case v8i8:
527>       case v4i16:
528>       case v2i32:
529>       case v1i64:
530>       case v4f16:
531>       case v2f32:
532>       case v1f64: return 64;
533488c407,428
534<       case ppcf128: return 128;
535---
536>       case ppcf128:
537>       case i128:
538>       case v16i8:
539>       case v8i16:
540>       case v4i32:
541>       case v2i64:
542>       case v8f16:
543>       case v4f32:
544>       case v2f64: return 128;
545>       case v32i8:
546>       case v16i16:
547>       case v8i32:
548>       case v4i64:
549>       case v8f32:
550>       case v4f64: return 256;
551>       case v64i8:
552>       case v32i16:
553>       case v16i32:
554>       case v8i64:
555>       case v16f32:
556>       case v8f64: return 512;
557>       case v16i64:return 1024;
558492,493d431
559<
560<
561548d485
562<
563555,558d491
564<       case 2:
565<         return MVT::i2;
566<       case 4:
567<         return MVT::i4;
568569,575d501
569<       case 256:
570<         return MVT::i256;
571<       case 512:
572<         return MVT::i512;
573<       case 1024:
574<         return MVT::i1024;
575<
576579,580d504
577<
578<
579586d509
580<         if (NumElements == 1)  return MVT::v1i1;
581593,619d515
582<         if (NumElements == 128)  return MVT::v128i1;
583<         if (NumElements == 256)  return MVT::v256i1;
584<         if (NumElements == 512)  return MVT::v512i1;
585<         if (NumElements == 1024)  return MVT::v1024i1;
586<         break;
587<       case MVT::i2:
588<         if (NumElements == 1)  return MVT::v1i2;
589<         if (NumElements == 2)  return MVT::v2i2;
590<         if (NumElements == 4)  return MVT::v4i2;
591<         if (NumElements == 8)  return MVT::v8i2;
592<         if (NumElements == 16)  return MVT::v16i2;
593<         if (NumElements == 32)  return MVT::v32i2;
594<         if (NumElements == 64)  return MVT::v64i2;
595<         if (NumElements == 128)  return MVT::v128i2;
596<         if (NumElements == 256)  return MVT::v256i2;
597<         if (NumElements == 512)  return MVT::v512i2;
598<         break;
599<       case MVT::i4:
600<         if (NumElements == 1)  return MVT::v1i4;
601<         if (NumElements == 2)  return MVT::v2i4;
602<         if (NumElements == 4)  return MVT::v4i4;
603<         if (NumElements == 8)  return MVT::v8i4;
604<         if (NumElements == 16)  return MVT::v16i4;
605<         if (NumElements == 32)  return MVT::v32i4;
606<         if (NumElements == 64)  return MVT::v64i4;
607<         if (NumElements == 128)  return MVT::v128i4;
608<         if (NumElements == 256)  return MVT::v256i4;
609629d524
610<         if (NumElements == 128)  return MVT::v128i8;
611638d532
612<         if (NumElements == 64)  return MVT::v64i16;
613646d539
614<         if (NumElements == 32)  return MVT::v32i32;
615655,672d547
616<       case MVT::i128:
617<         if (NumElements == 1)  return MVT::v1i128;
618<         if (NumElements == 2)  return MVT::v2i128;
619<         if (NumElements == 4)  return MVT::v4i128;
620<         if (NumElements == 8)  return MVT::v8i128;
621<         break;
622<       case MVT::i256:
623<         if (NumElements == 1)  return MVT::v1i256;
624<         if (NumElements == 2)  return MVT::v2i256;
625<         if (NumElements == 4)  return MVT::v4i256;
626<         break;
627<       case MVT::i512:
628<         if (NumElements == 1)  return MVT::v1i512;
629<         if (NumElements == 2)  return MVT::v2i512;
630<         break;
631<       case MVT::i1024:
632<         if (NumElements == 1)  return MVT::v1i1024;
633<         break;
634674d548
635<         if (NumElements == 1)  return MVT::v1f16;
636678,680d551
637<         if (NumElements == 16)  return MVT::v16f16;
638<         if (NumElements == 32)  return MVT::v32f16;
639<         if (NumElements == 64)  return MVT::v64f16;
640688d558
641<         if (NumElements == 32)  return MVT::v32f32;
642695d564
643<         if (NumElements == 16)  return MVT::v16f64;
644697d565
645<
646701d568
647<
648diff -r -b parabix-llvm/include/llvm/CodeGen/ValueTypes.h r209855/include/llvm/CodeGen/ValueTypes.h
649120,124d119
650<     /// isParabixVector - Return true if this is a parabix vector.
651<     bool isParabixVector() const {
652<       return isSimple() && V.isParabixVector();
653<     }
654<
655diff -r -b parabix-llvm/include/llvm/CodeGen/ValueTypes.td r209855/include/llvm/CodeGen/ValueTypes.td
65623,134c23,83
657< def i1        : ValueType<1 , 1>;
658< def i2        : ValueType<2 , 2>;
659< def i4        : ValueType<4 , 3>;
660< def i8        : ValueType<8 , 4>;
661< def i16       : ValueType<16 , 5>;
662< def i32       : ValueType<32 , 6>;
663< def i64       : ValueType<64 , 7>;
664< def i128      : ValueType<128 , 8>;
665< def i256      : ValueType<256 , 9>;
666< def i512      : ValueType<512 , 10>;
667< def i1024     : ValueType<1024 , 11>;
668<
669< def f16    : ValueType<16 , 12>;   // 16-bit floating point value
670< def f32    : ValueType<32 , 13>;   // 32-bit floating point value
671< def f64    : ValueType<64 , 14>;   // 64-bit floating point value
672< def f80    : ValueType<80 , 15>;   // 80-bit floating point value
673< def f128   : ValueType<128, 16>;   // 128-bit floating point value
674< def ppcf128: ValueType<128, 17>;   // PPC 128-bit floating point value
675<
676< def v1i1      : ValueType<1 , 18>;
677< def v2i1      : ValueType<2 , 19>;
678< def v4i1      : ValueType<4 , 20>;
679< def v8i1      : ValueType<8 , 21>;
680< def v16i1     : ValueType<16 , 22>;
681< def v32i1     : ValueType<32 , 23>;
682< def v64i1     : ValueType<64 , 24>;
683< def v128i1    : ValueType<128 , 25>;
684< def v256i1    : ValueType<256 , 26>;
685< def v512i1    : ValueType<512 , 27>;
686< def v1024i1   : ValueType<1024 , 28>;
687< def v1i2      : ValueType<2 , 29>;
688< def v2i2      : ValueType<4 , 30>;
689< def v4i2      : ValueType<8 , 31>;
690< def v8i2      : ValueType<16 , 32>;
691< def v16i2     : ValueType<32 , 33>;
692< def v32i2     : ValueType<64 , 34>;
693< def v64i2     : ValueType<128 , 35>;
694< def v128i2    : ValueType<256 , 36>;
695< def v256i2    : ValueType<512 , 37>;
696< def v512i2    : ValueType<1024 , 38>;
697< def v1i4      : ValueType<4 , 39>;
698< def v2i4      : ValueType<8 , 40>;
699< def v4i4      : ValueType<16 , 41>;
700< def v8i4      : ValueType<32 , 42>;
701< def v16i4     : ValueType<64 , 43>;
702< def v32i4     : ValueType<128 , 44>;
703< def v64i4     : ValueType<256 , 45>;
704< def v128i4    : ValueType<512 , 46>;
705< def v256i4    : ValueType<1024 , 47>;
706< def v1i8      : ValueType<8 , 48>;
707< def v2i8      : ValueType<16 , 49>;
708< def v4i8      : ValueType<32 , 50>;
709< def v8i8      : ValueType<64 , 51>;
710< def v16i8     : ValueType<128 , 52>;
711< def v32i8     : ValueType<256 , 53>;
712< def v64i8     : ValueType<512 , 54>;
713< def v128i8    : ValueType<1024 , 55>;
714< def v1i16     : ValueType<16 , 56>;
715< def v2i16     : ValueType<32 , 57>;
716< def v4i16     : ValueType<64 , 58>;
717< def v8i16     : ValueType<128 , 59>;
718< def v16i16    : ValueType<256 , 60>;
719< def v32i16    : ValueType<512 , 61>;
720< def v64i16    : ValueType<1024 , 62>;
721< def v1i32     : ValueType<32 , 63>;
722< def v2i32     : ValueType<64 , 64>;
723< def v4i32     : ValueType<128 , 65>;
724< def v8i32     : ValueType<256 , 66>;
725< def v16i32    : ValueType<512 , 67>;
726< def v32i32    : ValueType<1024 , 68>;
727< def v1i64     : ValueType<64 , 69>;
728< def v2i64     : ValueType<128 , 70>;
729< def v4i64     : ValueType<256 , 71>;
730< def v8i64     : ValueType<512 , 72>;
731< def v16i64    : ValueType<1024 , 73>;
732< def v1i128    : ValueType<128 , 74>;
733< def v2i128    : ValueType<256 , 75>;
734< def v4i128    : ValueType<512 , 76>;
735< def v8i128    : ValueType<1024 , 77>;
736< def v1i256    : ValueType<256 , 78>;
737< def v2i256    : ValueType<512 , 79>;
738< def v4i256    : ValueType<1024 , 80>;
739< def v1i512    : ValueType<512 , 81>;
740< def v2i512    : ValueType<1024 , 82>;
741< def v1i1024   : ValueType<1024 , 83>;
742<
743<
744< def v1f16     : ValueType<16 , 84>;
745< def v2f16     : ValueType<32 , 85>;
746< def v4f16     : ValueType<64 , 86>;
747< def v8f16     : ValueType<128 , 87>;
748< def v16f16    : ValueType<256 , 88>;
749< def v32f16    : ValueType<512 , 89>;
750< def v64f16    : ValueType<1024 , 90>;
751< def v1f32     : ValueType<32 , 91>;
752< def v2f32     : ValueType<64 , 92>;
753< def v4f32     : ValueType<128 , 93>;
754< def v8f32     : ValueType<256 , 94>;
755< def v16f32    : ValueType<512 , 95>;
756< def v32f32    : ValueType<1024 , 96>;
757< def v1f64     : ValueType<64 , 97>;
758< def v2f64     : ValueType<128 , 98>;
759< def v4f64     : ValueType<256 , 99>;
760< def v8f64     : ValueType<512 , 100>;
761< def v16f64    : ValueType<1024 , 101>;
762<
763<
764< def x86mmx : ValueType<64 , 102>;   // X86 MMX value
765< def FlagVT : ValueType<0  , 103>;   // Pre-RA sched glue
766< def isVoid : ValueType<0  , 104>;   // Produces no value
767< def untyped: ValueType<8  , 105>;   // Produces an untyped value
768<
769---
770> def i1     : ValueType<1  ,  1>;   // One bit boolean value
771> def i8     : ValueType<8  ,  2>;   // 8-bit integer value
772> def i16    : ValueType<16 ,  3>;   // 16-bit integer value
773> def i32    : ValueType<32 ,  4>;   // 32-bit integer value
774> def i64    : ValueType<64 ,  5>;   // 64-bit integer value
775> def i128   : ValueType<128,  6>;   // 128-bit integer value
776> def f16    : ValueType<16 ,  7>;   // 16-bit floating point value
777> def f32    : ValueType<32 ,  8>;   // 32-bit floating point value
778> def f64    : ValueType<64 ,  9>;   // 64-bit floating point value
779> def f80    : ValueType<80 , 10>;   // 80-bit floating point value
780> def f128   : ValueType<128, 11>;   // 128-bit floating point value
781> def ppcf128: ValueType<128, 12>;   // PPC 128-bit floating point value
782>
783> def v2i1   : ValueType<2 ,  13>;   //  2 x i1  vector value
784> def v4i1   : ValueType<4 ,  14>;   //  4 x i1  vector value
785> def v8i1   : ValueType<8 ,  15>;   //  8 x i1  vector value
786> def v16i1  : ValueType<16,  16>;   // 16 x i1  vector value
787> def v32i1  : ValueType<32 , 17>;   // 32 x i1  vector value
788> def v64i1  : ValueType<64 , 18>;   // 64 x i1  vector value
789> def v1i8   : ValueType<16, 19>;    //  1 x i8  vector value
790> def v2i8   : ValueType<16 , 20>;   //  2 x i8  vector value
791> def v4i8   : ValueType<32 , 21>;   //  4 x i8  vector value
792> def v8i8   : ValueType<64 , 22>;   //  8 x i8  vector value
793> def v16i8  : ValueType<128, 23>;   // 16 x i8  vector value
794> def v32i8  : ValueType<256, 24>;   // 32 x i8 vector value
795> def v64i8  : ValueType<512, 25>;   // 64 x i8 vector value
796> def v1i16  : ValueType<16 , 26>;   //  1 x i16 vector value
797> def v2i16  : ValueType<32 , 27>;   //  2 x i16 vector value
798> def v4i16  : ValueType<64 , 28>;   //  4 x i16 vector value
799> def v8i16  : ValueType<128, 29>;   //  8 x i16 vector value
800> def v16i16 : ValueType<256, 30>;   // 16 x i16 vector value
801> def v32i16 : ValueType<512, 31>;   // 32 x i16 vector value
802> def v1i32  : ValueType<32 , 32>;   //  1 x i32 vector value
803> def v2i32  : ValueType<64 , 33>;   //  2 x i32 vector value
804> def v4i32  : ValueType<128, 34>;   //  4 x i32 vector value
805> def v8i32  : ValueType<256, 35>;   //  8 x i32 vector value
806> def v16i32 : ValueType<512, 36>;   // 16 x i32 vector value
807> def v1i64  : ValueType<64 , 37>;   //  1 x i64 vector value
808> def v2i64  : ValueType<128, 38>;   //  2 x i64 vector value
809> def v4i64  : ValueType<256, 39>;   //  4 x i64 vector value
810> def v8i64  : ValueType<512, 40>;   //  8 x i64 vector value
811> def v16i64 : ValueType<1024,41>;   // 16 x i64 vector value
812>
813> def v2f16  : ValueType<32 , 42>;   //  2 x f16 vector value
814> def v4f16  : ValueType<64 , 43>;   //  4 x f16 vector value
815> def v8f16  : ValueType<128, 44>;   //  8 x f16 vector value
816> def v1f32  : ValueType<32 , 45>;   //  1 x f32 vector value
817> def v2f32  : ValueType<64 , 46>;   //  2 x f32 vector value
818> def v4f32  : ValueType<128, 47>;   //  4 x f32 vector value
819> def v8f32  : ValueType<256, 48>;   //  8 x f32 vector value
820> def v16f32 : ValueType<512, 49>;   // 16 x f32 vector value
821> def v1f64  : ValueType<64, 50>;    //  1 x f64 vector value
822> def v2f64  : ValueType<128, 51>;   //  2 x f64 vector value
823> def v4f64  : ValueType<256, 52>;   //  4 x f64 vector value
824> def v8f64  : ValueType<512, 53>;   //  8 x f64 vector value
825>
826>
827> def x86mmx : ValueType<64 , 54>;   // X86 MMX value
828> def FlagVT : ValueType<0  , 55>;   // Pre-RA sched glue
829> def isVoid : ValueType<0  , 56>;   // Produces no value
830> def untyped: ValueType<8  , 57>;   // Produces an untyped value
831diff -r -b parabix-llvm/include/llvm/IR/Intrinsics.td r209855/include/llvm/IR/Intrinsics.td
832437,440d436
833< def int_uadd_with_overflow_carryin : Intrinsic<[llvm_anyint_ty, llvm_i1_ty],
834<                                        [LLVMMatchType<0>, LLVMMatchType<0>, llvm_i1_ty],
835<                                        [IntrNoMem]>;
836<
837diff -r -b parabix-llvm/include/llvm/IR/IntrinsicsX86.td r209855/include/llvm/IR/IntrinsicsX86.td
8381306a1307,1315
839>   def int_x86_avx_vbroadcast_ss :
840>         GCCBuiltin<"__builtin_ia32_vbroadcastss">,
841>         Intrinsic<[llvm_v4f32_ty], [llvm_ptr_ty], [IntrReadArgMem]>;
842>   def int_x86_avx_vbroadcast_sd_256 :
843>         GCCBuiltin<"__builtin_ia32_vbroadcastsd256">,
844>         Intrinsic<[llvm_v4f64_ty], [llvm_ptr_ty], [IntrReadArgMem]>;
845>   def int_x86_avx_vbroadcast_ss_256 :
846>         GCCBuiltin<"__builtin_ia32_vbroadcastss256">,
847>         Intrinsic<[llvm_v8f32_ty], [llvm_ptr_ty], [IntrReadArgMem]>;
848diff -r -b parabix-llvm/include/llvm/Target/TargetLowering.h r209855/include/llvm/Target/TargetLowering.h
849465,470d464
850<     //FIXME: Parabix hack here, i2/i4 is not extended now, but it
851<     //seems LLVM has an assumption that i2/i4 will always expand.
852<     if (VT.getSimpleVT() == MVT::i2 ||
853<         VT.getSimpleVT() == MVT::i4)
854<       return Expand;
855<
856478,492d471
857<   /// Parabix: similar to getOperationAction, but always use
858<   /// operand[0] as the VT here.
859<   LegalizeAction getOperand0Action(ISD::NodeType Op, EVT VT) const {
860<     // FIXME: we only use operand0action for simpleTy for now.
861<     if (VT.isExtended()) return Legal;
862<
863<     Operand0ActionsKeyTy key = std::make_pair(VT.getSimpleVT(), Op);
864<     auto iter = Operand0Actions.find(key);
865<     if (iter == Operand0Actions.end()) {
866<       return Legal;
867<     } else {
868<       return iter->second;
869<     }
870<   }
871<
8721098,1111d1076
873<   /// Parabix
874<   /// Indicate that the specified operation does not work with the
875<   /// specified operand type, and indicate what to do about it.
876<   void setOperand0Action(ISD::NodeType Op, MVT VT,
877<                         LegalizeAction Action) {
878<     assert(Op < array_lengthof(OpActions[0]) && "Op too large for the table");
879<     Operand0ActionsKeyTy key = std::make_pair(VT, Op);
880<     Operand0Actions[key] = Action;
881<   }
882<
883<   void resetOperand0Action() {
884<     Operand0Actions.clear();
885<   }
886<
8871599,1602d1563
888<
889<   /// Same with OpActions, but for Operand(0)
890<   typedef std::pair<MVT, ISD::NodeType> Operand0ActionsKeyTy;
891<   std::map<Operand0ActionsKeyTy, LegalizeAction> Operand0Actions;
892diff -r -b parabix-llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp r209855/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
8931292,1297d1291
894<       // Parabix: test if we want to custom it with operand0 action.
895<       if (Node->getNumOperands() > 0) {
896<         Action = TLI.getOperand0Action((ISD::NodeType) Node->getOpcode(), Node->getOperand(0).getValueType());
897<         if (Action == TargetLowering::Legal)
898<           Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
899<       } else
9001389,1390d1382
901<
902<
903diff -r -b parabix-llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp r209855/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
9045326,5334d5325
905<   case Intrinsic::uadd_with_overflow_carryin: {
906<     SDValue Op1 = getValue(I.getArgOperand(0));
907<     SDValue Op2 = getValue(I.getArgOperand(1));
908<     SDValue Op3 = getValue(I.getArgOperand(2));
909<
910<     SDVTList VTs = DAG.getVTList(Op1.getValueType(), MVT::i1);
911<     setValue(&I, DAG.getNode(ISD::UADDE, sdl, VTs, Op1, Op2, Op3));
912<     return nullptr;
913<   }
914diff -r -b parabix-llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp r209855/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
915208d207
916<   case ISD::UADDE:                      return "uadde";
917diff -r -b parabix-llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp r209855/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
9182468c2468
919<         NodeToMatch->dumprFull(CurDAG);
920---
921>         NodeToMatch->dump(CurDAG);
922diff -r -b parabix-llvm/lib/CodeGen/TargetLoweringBase.cpp r209855/lib/CodeGen/TargetLoweringBase.cpp
9231100,1101c1100
924<             isTypeLegal(SVT) && SVT.getScalarType().isInteger() &&
925<             !SVT.isParabixVector()) {
926---
927>             isTypeLegal(SVT) && SVT.getScalarType().isInteger()) {
9281118c1117
929<             isTypeLegal(SVT) && !SVT.isParabixVector()) {
930---
931>             isTypeLegal(SVT)) {
932diff -r -b parabix-llvm/lib/IR/AutoUpgrade.cpp r209855/lib/IR/AutoUpgrade.cpp
933117,119d116
934<         Name == "x86.avx.vbroadcast.ss" ||
935<         Name == "x86.avx.vbroadcast.ss.256" ||
936<         Name == "x86.avx.vbroadcast.sd.256" ||
937341,353d337
938<     } else if (Name.startswith("llvm.x86.avx.vbroadcast")) {
939<       // Replace broadcasts with a series of insertelements.
940<       Type *VecTy = CI->getType();
941<       Type *EltTy = VecTy->getVectorElementType();
942<       unsigned EltNum = VecTy->getVectorNumElements();
943<       Value *Cast = Builder.CreateBitCast(CI->getArgOperand(0),
944<                                           EltTy->getPointerTo());
945<       Value *Load = Builder.CreateLoad(Cast);
946<       Type *I32Ty = Type::getInt32Ty(C);
947<       Rep = UndefValue::get(VecTy);
948<       for (unsigned I = 0; I < EltNum; ++I)
949<         Rep = Builder.CreateInsertElement(Rep, Load,
950<                                           ConstantInt::get(I32Ty, I));
951diff -r -b parabix-llvm/lib/IR/ValueTypes.cpp r209855/lib/IR/ValueTypes.cpp
95220d19
953< #include "llvm/Support/Debug.h"
954184d182
955<     dbgs() << "EVT String: " << getEVTString() << '\n';
956189,190d186
957<   case MVT::i2:      return Type::getIntNTy(Context, 2);
958<   case MVT::i4:      return Type::getIntNTy(Context, 4);
959196,198d191
960<   case MVT::i256:    return IntegerType::get(Context, 256);
961<   case MVT::i512:    return IntegerType::get(Context, 512);
962<   case MVT::i1024:   return IntegerType::get(Context, 1024);
963206,207d198
964<
965<   case MVT::v1i1:   return VectorType::get(Type::getInt1Ty(Context), 1);
966209d199
967<   case MVT::v1i2:   return VectorType::get(Type::getIntNTy(Context, 2), 1);
968211,212d200
969<   case MVT::v2i2:   return VectorType::get(Type::getIntNTy(Context, 2), 2);
970<   case MVT::v1i4:   return VectorType::get(Type::getIntNTy(Context, 4), 1);
971214,216d201
972<   case MVT::v4i2:   return VectorType::get(Type::getIntNTy(Context, 2), 4);
973<   case MVT::v2i4:   return VectorType::get(Type::getIntNTy(Context, 4), 2);
974<   case MVT::v1i8:   return VectorType::get(Type::getInt8Ty(Context), 1);
975218,221d202
976<   case MVT::v8i2:   return VectorType::get(Type::getIntNTy(Context, 2), 8);
977<   case MVT::v4i4:   return VectorType::get(Type::getIntNTy(Context, 4), 4);
978<   case MVT::v2i8:   return VectorType::get(Type::getInt8Ty(Context), 2);
979<   case MVT::v1i16:   return VectorType::get(Type::getInt16Ty(Context), 1);
980223,227d203
981<   case MVT::v16i2:   return VectorType::get(Type::getIntNTy(Context, 2), 16);
982<   case MVT::v8i4:   return VectorType::get(Type::getIntNTy(Context, 4), 8);
983<   case MVT::v4i8:   return VectorType::get(Type::getInt8Ty(Context), 4);
984<   case MVT::v2i16:   return VectorType::get(Type::getInt16Ty(Context), 2);
985<   case MVT::v1i32:   return VectorType::get(Type::getInt32Ty(Context), 1);
986229,230c205,207
987<   case MVT::v32i2:   return VectorType::get(Type::getIntNTy(Context, 2), 32);
988<   case MVT::v16i4:   return VectorType::get(Type::getIntNTy(Context, 4), 16);
989---
990>   case MVT::v1i8:    return VectorType::get(Type::getInt8Ty(Context), 1);
991>   case MVT::v2i8:    return VectorType::get(Type::getInt8Ty(Context), 2);
992>   case MVT::v4i8:    return VectorType::get(Type::getInt8Ty(Context), 4);
993232,237d208
994<   case MVT::v4i16:   return VectorType::get(Type::getInt16Ty(Context), 4);
995<   case MVT::v2i32:   return VectorType::get(Type::getInt32Ty(Context), 2);
996<   case MVT::v1i64:   return VectorType::get(Type::getInt64Ty(Context), 1);
997<   case MVT::v128i1:   return VectorType::get(Type::getInt1Ty(Context), 128);
998<   case MVT::v64i2:   return VectorType::get(Type::getIntNTy(Context, 2), 64);
999<   case MVT::v32i4:   return VectorType::get(Type::getIntNTy(Context, 4), 32);
1000239,245d209
1001<   case MVT::v8i16:   return VectorType::get(Type::getInt16Ty(Context), 8);
1002<   case MVT::v4i32:   return VectorType::get(Type::getInt32Ty(Context), 4);
1003<   case MVT::v2i64:   return VectorType::get(Type::getInt64Ty(Context), 2);
1004<   case MVT::v1i128:   return VectorType::get(Type::getIntNTy(Context, 128), 1);
1005<   case MVT::v256i1:   return VectorType::get(Type::getInt1Ty(Context), 256);
1006<   case MVT::v128i2:   return VectorType::get(Type::getIntNTy(Context, 2), 128);
1007<   case MVT::v64i4:   return VectorType::get(Type::getIntNTy(Context, 4), 64);
1008247,254d210
1009<   case MVT::v16i16:   return VectorType::get(Type::getInt16Ty(Context), 16);
1010<   case MVT::v8i32:   return VectorType::get(Type::getInt32Ty(Context), 8);
1011<   case MVT::v4i64:   return VectorType::get(Type::getInt64Ty(Context), 4);
1012<   case MVT::v2i128:   return VectorType::get(Type::getIntNTy(Context, 128), 2);
1013<   case MVT::v1i256:   return VectorType::get(Type::getIntNTy(Context, 256), 1);
1014<   case MVT::v512i1:   return VectorType::get(Type::getInt1Ty(Context), 512);
1015<   case MVT::v256i2:   return VectorType::get(Type::getIntNTy(Context, 2), 256);
1016<   case MVT::v128i4:   return VectorType::get(Type::getIntNTy(Context, 4), 128);
1017255a212,216
1018>   case MVT::v1i16:   return VectorType::get(Type::getInt16Ty(Context), 1);
1019>   case MVT::v2i16:   return VectorType::get(Type::getInt16Ty(Context), 2);
1020>   case MVT::v4i16:   return VectorType::get(Type::getInt16Ty(Context), 4);
1021>   case MVT::v8i16:   return VectorType::get(Type::getInt16Ty(Context), 8);
1022>   case MVT::v16i16:  return VectorType::get(Type::getInt16Ty(Context), 16);
1023256a218,221
1024>   case MVT::v1i32:   return VectorType::get(Type::getInt32Ty(Context), 1);
1025>   case MVT::v2i32:   return VectorType::get(Type::getInt32Ty(Context), 2);
1026>   case MVT::v4i32:   return VectorType::get(Type::getInt32Ty(Context), 4);
1027>   case MVT::v8i32:   return VectorType::get(Type::getInt32Ty(Context), 8);
1028257a223,225
1029>   case MVT::v1i64:   return VectorType::get(Type::getInt64Ty(Context), 1);
1030>   case MVT::v2i64:   return VectorType::get(Type::getInt64Ty(Context), 2);
1031>   case MVT::v4i64:   return VectorType::get(Type::getInt64Ty(Context), 4);
1032259,267d226
1033<   case MVT::v4i128:   return VectorType::get(Type::getIntNTy(Context, 128), 4);
1034<   case MVT::v2i256:   return VectorType::get(Type::getIntNTy(Context, 256), 2);
1035<   case MVT::v1i512:   return VectorType::get(Type::getIntNTy(Context, 512), 1);
1036<   case MVT::v1024i1:   return VectorType::get(Type::getInt1Ty(Context), 1024);
1037<   case MVT::v512i2:   return VectorType::get(Type::getIntNTy(Context, 2), 512);
1038<   case MVT::v256i4:   return VectorType::get(Type::getIntNTy(Context, 4), 256);
1039<   case MVT::v128i8:   return VectorType::get(Type::getInt8Ty(Context), 128);
1040<   case MVT::v64i16:   return VectorType::get(Type::getInt16Ty(Context), 64);
1041<   case MVT::v32i32:   return VectorType::get(Type::getInt32Ty(Context), 32);
1042269,274d227
1043<   case MVT::v8i128:   return VectorType::get(Type::getIntNTy(Context, 128), 8);
1044<   case MVT::v4i256:   return VectorType::get(Type::getIntNTy(Context, 256), 4);
1045<   case MVT::v2i512:   return VectorType::get(Type::getIntNTy(Context, 512), 2);
1046<   case MVT::v1i1024:   return VectorType::get(Type::getIntNTy(Context, 1024), 1);
1047<
1048<   case MVT::v1f16:   return VectorType::get(Type::getHalfTy(Context), 1);
1049276d228
1050<   case MVT::v1f32:   return VectorType::get(Type::getFloatTy(Context), 1);
1051278,279d229
1052<   case MVT::v2f32:   return VectorType::get(Type::getFloatTy(Context), 2);
1053<   case MVT::v1f64:   return VectorType::get(Type::getDoubleTy(Context), 1);
1054280a231,232
1055>   case MVT::v1f32:   return VectorType::get(Type::getFloatTy(Context), 1);
1056>   case MVT::v2f32:   return VectorType::get(Type::getFloatTy(Context), 2);
1057282,283d233
1058<   case MVT::v2f64:   return VectorType::get(Type::getDoubleTy(Context), 2);
1059<   case MVT::v16f16:   return VectorType::get(Type::getHalfTy(Context), 16);
1060285,286d234
1061<   case MVT::v4f64:   return VectorType::get(Type::getDoubleTy(Context), 4);
1062<   case MVT::v32f16:   return VectorType::get(Type::getHalfTy(Context), 32);
1063287a236,238
1064>   case MVT::v1f64:   return VectorType::get(Type::getDoubleTy(Context), 1);
1065>   case MVT::v2f64:   return VectorType::get(Type::getDoubleTy(Context), 2);
1066>   case MVT::v4f64:   return VectorType::get(Type::getDoubleTy(Context), 4);
1067289,293d239
1068<   case MVT::v64f16:   return VectorType::get(Type::getHalfTy(Context), 64);
1069<   case MVT::v32f32:   return VectorType::get(Type::getFloatTy(Context), 32);
1070<   case MVT::v16f64:   return VectorType::get(Type::getDoubleTy(Context), 16);
1071<
1072<
1073diff -r -b parabix-llvm/lib/Target/X86/CMakeLists.txt r209855/lib/Target/X86/CMakeLists.txt
107423d22
1075<   X86ParabixISelLowering.cpp
1076Only in parabix-llvm/lib/Target/X86: ParabixGeneratedFuncs.h
1077diff -r -b parabix-llvm/lib/Target/X86/X86CallingConv.td r209855/lib/Target/X86/X86CallingConv.td
107840,43d39
1079<   //Parabix
1080<   CCIfType<[v32i1], CCAssignToReg<[EAX, EDX, ECX]>>,
1081<   CCIfType<[v64i1], CCAssignToReg<[RAX, RDX, RCX]>>,
1082<
108350,53d45
1084<   //Parabix 128-bit vectors
1085<   CCIfType<[v64i2, v32i4, v128i1],
1086<             CCAssignToReg<[XMM0,XMM1,XMM2,XMM3]>>,
1087<
1088101,103d92
1089<   //Parabix
1090<   CCIfType<[v32i1], CCAssignToReg<[EAX, EDX, ECX]>>,
1091<
1092244,247d232
1093<   // Parabix
1094<   CCIfType<[v32i1], CCAssignToReg<[EDI, ESI, EDX, ECX, R8D, R9D]>>,
1095<   CCIfType<[v64i1], CCAssignToReg<[RDI, RSI, RDX, RCX, R8 , R9 ]>>,
1096<
1097259,263d243
1098<   //Parabix
1099<   CCIfType<[v64i2, v32i4, v128i1],
1100<             CCIfSubtarget<"hasSSE2()",
1101<             CCAssignToReg<[XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7]>>>,
1102<
1103281c261
1104<   CCIfType<[i32, i64, v32i1, v64i1, f32, f64], CCAssignToStack<8, 8>>,
1105---
1106>   CCIfType<[i32, i64, f32, f64], CCAssignToStack<8, 8>>,
1107288c268
1108<   CCIfType<[v16i8, v8i16, v4i32, v2i64, v64i2, v32i4, v4f32, v2f64, v128i1], CCAssignToStack<16, 16>>,
1109---
1110>   CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], CCAssignToStack<16, 16>>,
1111311c291
1112<   CCIfType<[v16i8, v8i16, v4i32, v2i64, v32i4, v64i2, v4f32, v2f64, v128i1], CCPassIndirect<i64>>,
1113---
1114>   CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], CCPassIndirect<i64>>,
1115337c317
1116<   CCIfType<[f32, f64, v32i4, v64i2, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64, v128i1],
1117---
1118>   CCIfType<[f32, f64, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
1119358,360d337
1120<   CCIfType<[v64i1],
1121<             CCAssignToReg<[R13, RBP, R12, RBX, R14, RSI, RDI, R8, R9, R15]>>,
1122<
1123362c339
1124<   CCIfType<[f32, f64, v64i2, v32i4, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64, v128i1],
1125---
1126>   CCIfType<[f32, f64, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
1127373d349
1128<   CCIfType<[v64i1], CCAssignToReg<[R15, RBP, RSI, RDX, RCX, R8]>>,
1129439c415
1130<   CCIfNotVarArg<CCIfType<[v64i2, v32i4, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64, v128i1],
1131---
1132>   CCIfNotVarArg<CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
1133448c424
1134<   CCIfType<[v64i2, v32i4, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64, v128i1], CCAssignToStack<16, 16>>,
1135---
1136>   CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], CCAssignToStack<16, 16>>,
1137diff -r -b parabix-llvm/lib/Target/X86/X86InstrFragmentsSIMD.td r209855/lib/Target/X86/X86InstrFragmentsSIMD.td
1138227,230d226
1139< def SDTPack : SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, SDTCisSameAs<2, 1>]>;
1140< def X86Packss : SDNode<"X86ISD::PACKSS", SDTPack>;
1141< def X86Packus : SDNode<"X86ISD::PACKUS", SDTPack>;
1142<
1143diff -r -b parabix-llvm/lib/Target/X86/X86InstrInfo.cpp r209855/lib/Target/X86/X86InstrInfo.cpp
11441614d1613
1145<   {
11461618d1616
1147<   }
1148diff -r -b parabix-llvm/lib/Target/X86/X86InstrInfo.td r209855/lib/Target/X86/X86InstrInfo.td
11492221,2270d2220
1150<
1151< //TODO: isn't this redundant???
1152< //Parabix: bit convert v32i1 to i32, v64i1 to i64
1153< def : Pat <(i32 (bitconvert (v32i1 GR32X:$src))), (i32 GR32X:$src)>;
1154< def : Pat <(i64 (bitconvert (v64i1 GR64X:$src))), (i64 GR64X:$src)>;
1155< //Parabix: bitconvert from v64i2 vector
1156< def : Pat <(v16i8 (bitconvert (v64i2 VR128PX:$src))), (v16i8 VR128PX:$src)>;
1157< def : Pat <(v8i16 (bitconvert (v64i2 VR128PX:$src))), (v8i16 VR128PX:$src)>;
1158< def : Pat <(v4i32 (bitconvert (v64i2 VR128PX:$src))), (v4i32 VR128PX:$src)>;
1159< def : Pat <(v2i64 (bitconvert (v64i2 VR128PX:$src))), (v2i64 VR128PX:$src)>;
1160< def : Pat <(v4f32 (bitconvert (v64i2 VR128PX:$src))), (v4f32 VR128PX:$src)>;
1161< def : Pat <(v2f64 (bitconvert (v64i2 VR128PX:$src))), (v2f64 VR128PX:$src)>;
1162< def : Pat <(v64i2 (bitconvert (v2i64 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1163< def : Pat <(v64i2 (bitconvert (v4i32 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1164< def : Pat <(v64i2 (bitconvert (v8i16 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1165< def : Pat <(v64i2 (bitconvert (v16i8 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1166< def : Pat <(v64i2 (bitconvert (v2f64 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1167< def : Pat <(v64i2 (bitconvert (v4f32 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1168< //Parabix bitconvert from/to v32i4 vector
1169< def : Pat <(v64i2 (bitconvert (v32i4 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1170< def : Pat <(v16i8 (bitconvert (v32i4 VR128PX:$src))), (v16i8 VR128PX:$src)>;
1171< def : Pat <(v8i16 (bitconvert (v32i4 VR128PX:$src))), (v8i16 VR128PX:$src)>;
1172< def : Pat <(v4i32 (bitconvert (v32i4 VR128PX:$src))), (v4i32 VR128PX:$src)>;
1173< def : Pat <(v2i64 (bitconvert (v32i4 VR128PX:$src))), (v2i64 VR128PX:$src)>;
1174< def : Pat <(v4f32 (bitconvert (v32i4 VR128PX:$src))), (v4f32 VR128PX:$src)>;
1175< def : Pat <(v2f64 (bitconvert (v32i4 VR128PX:$src))), (v2f64 VR128PX:$src)>;
1176< def : Pat <(v32i4 (bitconvert (v2i64 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1177< def : Pat <(v32i4 (bitconvert (v4i32 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1178< def : Pat <(v32i4 (bitconvert (v8i16 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1179< def : Pat <(v32i4 (bitconvert (v16i8 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1180< def : Pat <(v32i4 (bitconvert (v64i2 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1181< def : Pat <(v32i4 (bitconvert (v2f64 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1182< def : Pat <(v32i4 (bitconvert (v4f32 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1183< //Parabix bitconvert from/to v128i1 vector
1184< def : Pat <(v64i2 (bitconvert (v128i1 VR128PX:$src))), (v64i2 VR128PX:$src)>;
1185< def : Pat <(v32i4 (bitconvert (v128i1 VR128PX:$src))), (v32i4 VR128PX:$src)>;
1186< def : Pat <(v16i8 (bitconvert (v128i1 VR128PX:$src))), (v16i8 VR128PX:$src)>;
1187< def : Pat <(v8i16 (bitconvert (v128i1 VR128PX:$src))), (v8i16 VR128PX:$src)>;
1188< def : Pat <(v4i32 (bitconvert (v128i1 VR128PX:$src))), (v4i32 VR128PX:$src)>;
1189< def : Pat <(v2i64 (bitconvert (v128i1 VR128PX:$src))), (v2i64 VR128PX:$src)>;
1190< def : Pat <(v4f32 (bitconvert (v128i1 VR128PX:$src))), (v4f32 VR128PX:$src)>;
1191< def : Pat <(v2f64 (bitconvert (v128i1 VR128PX:$src))), (v2f64 VR128PX:$src)>;
1192< def : Pat <(v128i1 (bitconvert (v2i64 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1193< def : Pat <(v128i1 (bitconvert (v4i32 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1194< def : Pat <(v128i1 (bitconvert (v8i16 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1195< def : Pat <(v128i1 (bitconvert (v16i8 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1196< def : Pat <(v128i1 (bitconvert (v32i4 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1197< def : Pat <(v128i1 (bitconvert (v64i2 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1198< def : Pat <(v128i1 (bitconvert (v2f64 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1199< def : Pat <(v128i1 (bitconvert (v4f32 VR128PX:$src))), (v128i1 VR128PX:$src)>;
1200diff -r -b parabix-llvm/lib/Target/X86/X86InstrSSE.td r209855/lib/Target/X86/X86InstrSSE.td
12014339a4340,4353
1202> // SSE2 - Packed Integer Pack Instructions
1203> //===---------------------------------------------------------------------===//
1204>
1205> defm PACKSSWB : PDI_binop_all_int<0x63, "packsswb", int_x86_sse2_packsswb_128,
1206>                                   int_x86_avx2_packsswb,
1207>                                   SSE_INTALU_ITINS_SHUFF_P, 0>;
1208> defm PACKSSDW : PDI_binop_all_int<0x6B, "packssdw", int_x86_sse2_packssdw_128,
1209>                                   int_x86_avx2_packssdw,
1210>                                   SSE_INTALU_ITINS_SHUFF_P, 0>;
1211> defm PACKUSWB : PDI_binop_all_int<0x67, "packuswb", int_x86_sse2_packuswb_128,
1212>                                   int_x86_avx2_packuswb,
1213>                                   SSE_INTALU_ITINS_SHUFF_P, 0>;
1214>
1215> //===---------------------------------------------------------------------===//
12164421,4550d4434
1217< // Packed Integer Pack Instructions (SSE & AVX)
1218< //===---------------------------------------------------------------------===//
1219<
1220< let ExeDomain = SSEPackedInt in {
1221< multiclass sse2_pack<bits<8> opc, string OpcodeStr, ValueType OutVT,
1222<                      ValueType ArgVT, SDNode OpNode, PatFrag bc_frag,
1223<                      bit Is2Addr = 1> {
1224<   def rr : PDI<opc, MRMSrcReg,
1225<                (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1226<                !if(Is2Addr,
1227<                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1228<                    !strconcat(OpcodeStr,
1229<                               "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1230<                [(set VR128:$dst,
1231<                      (OutVT (OpNode (ArgVT VR128:$src1), VR128:$src2)))]>,
1232<                Sched<[WriteShuffle]>;
1233<   def rm : PDI<opc, MRMSrcMem,
1234<                (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
1235<                !if(Is2Addr,
1236<                    !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1237<                    !strconcat(OpcodeStr,
1238<                               "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1239<                [(set VR128:$dst,
1240<                      (OutVT (OpNode VR128:$src1,
1241<                                     (bc_frag (memopv2i64 addr:$src2)))))]>,
1242<                Sched<[WriteShuffleLd, ReadAfterLd]>;
1243< }
1244<
1245< multiclass sse2_pack_y<bits<8> opc, string OpcodeStr, ValueType OutVT,
1246<                        ValueType ArgVT, SDNode OpNode, PatFrag bc_frag> {
1247<   def Yrr : PDI<opc, MRMSrcReg,
1248<                 (outs VR256:$dst), (ins VR256:$src1, VR256:$src2),
1249<                 !strconcat(OpcodeStr,
1250<                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1251<                 [(set VR256:$dst,
1252<                       (OutVT (OpNode (ArgVT VR256:$src1), VR256:$src2)))]>,
1253<                 Sched<[WriteShuffle]>;
1254<   def Yrm : PDI<opc, MRMSrcMem,
1255<                 (outs VR256:$dst), (ins VR256:$src1, i256mem:$src2),
1256<                 !strconcat(OpcodeStr,
1257<                            "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1258<                 [(set VR256:$dst,
1259<                       (OutVT (OpNode VR256:$src1,
1260<                                      (bc_frag (memopv4i64 addr:$src2)))))]>,
1261<                 Sched<[WriteShuffleLd, ReadAfterLd]>;
1262< }
1263<
1264< multiclass sse4_pack<bits<8> opc, string OpcodeStr, ValueType OutVT,
1265<                      ValueType ArgVT, SDNode OpNode, PatFrag bc_frag,
1266<                      bit Is2Addr = 1> {
1267<   def rr : SS48I<opc, MRMSrcReg,
1268<                  (outs VR128:$dst), (ins VR128:$src1, VR128:$src2),
1269<                  !if(Is2Addr,
1270<                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1271<                      !strconcat(OpcodeStr,
1272<                                 "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1273<                  [(set VR128:$dst,
1274<                        (OutVT (OpNode (ArgVT VR128:$src1), VR128:$src2)))]>,
1275<                  Sched<[WriteShuffle]>;
1276<   def rm : SS48I<opc, MRMSrcMem,
1277<                  (outs VR128:$dst), (ins VR128:$src1, i128mem:$src2),
1278<                  !if(Is2Addr,
1279<                      !strconcat(OpcodeStr, "\t{$src2, $dst|$dst, $src2}"),
1280<                      !strconcat(OpcodeStr,
1281<                                 "\t{$src2, $src1, $dst|$dst, $src1, $src2}")),
1282<                  [(set VR128:$dst,
1283<                        (OutVT (OpNode VR128:$src1,
1284<                                       (bc_frag (memopv2i64 addr:$src2)))))]>,
1285<                  Sched<[WriteShuffleLd, ReadAfterLd]>;
1286< }
1287<
1288< multiclass sse4_pack_y<bits<8> opc, string OpcodeStr, ValueType OutVT,
1289<                      ValueType ArgVT, SDNode OpNode, PatFrag bc_frag> {
1290<   def Yrr : SS48I<opc, MRMSrcReg,
1291<                   (outs VR256:$dst), (ins VR256:$src1, VR256:$src2),
1292<                   !strconcat(OpcodeStr,
1293<                              "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1294<                   [(set VR256:$dst,
1295<                         (OutVT (OpNode (ArgVT VR256:$src1), VR256:$src2)))]>,
1296<                   Sched<[WriteShuffle]>;
1297<   def Yrm : SS48I<opc, MRMSrcMem,
1298<                   (outs VR256:$dst), (ins VR256:$src1, i256mem:$src2),
1299<                   !strconcat(OpcodeStr,
1300<                              "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1301<                   [(set VR256:$dst,
1302<                         (OutVT (OpNode VR256:$src1,
1303<                                        (bc_frag (memopv4i64 addr:$src2)))))]>,
1304<                   Sched<[WriteShuffleLd, ReadAfterLd]>;
1305< }
1306<
1307< let Predicates = [HasAVX] in {
1308<   defm VPACKSSWB : sse2_pack<0x63, "vpacksswb", v16i8, v8i16, X86Packss,
1309<                              bc_v8i16, 0>, VEX_4V;
1310<   defm VPACKSSDW : sse2_pack<0x6B, "vpackssdw", v8i16, v4i32, X86Packss,
1311<                              bc_v4i32, 0>, VEX_4V;
1312<
1313<   defm VPACKUSWB : sse2_pack<0x67, "vpackuswb", v16i8, v8i16, X86Packus,
1314<                              bc_v8i16, 0>, VEX_4V;
1315<   defm VPACKUSDW : sse4_pack<0x2B, "vpackusdw", v8i16, v4i32, X86Packus,
1316<                              bc_v4i32, 0>, VEX_4V;
1317< }
1318<
1319< let Predicates = [HasAVX2] in {
1320<   defm VPACKSSWB : sse2_pack_y<0x63, "vpacksswb", v32i8, v16i16, X86Packss,
1321<                                bc_v16i16>, VEX_4V, VEX_L;
1322<   defm VPACKSSDW : sse2_pack_y<0x6B, "vpackssdw", v16i16, v8i32, X86Packss,
1323<                                bc_v8i32>, VEX_4V, VEX_L;
1324<
1325<   defm VPACKUSWB : sse2_pack_y<0x67, "vpackuswb", v32i8, v16i16, X86Packus,
1326<                                bc_v16i16>, VEX_4V, VEX_L;
1327<   defm VPACKUSDW : sse4_pack_y<0x2B, "vpackusdw", v16i16, v8i32, X86Packus,
1328<                                bc_v8i32>, VEX_4V, VEX_L;
1329< }
1330<
1331< let Constraints = "$src1 = $dst" in {
1332<   defm PACKSSWB : sse2_pack<0x63, "packsswb", v16i8, v8i16, X86Packss,
1333<                             bc_v8i16>;
1334<   defm PACKSSDW : sse2_pack<0x6B, "packssdw", v8i16, v4i32, X86Packss,
1335<                             bc_v4i32>;
1336<
1337<   defm PACKUSWB : sse2_pack<0x67, "packuswb", v16i8, v8i16, X86Packus,
1338<                             bc_v8i16>;
1339<
1340<   let Predicates = [HasSSE41] in
1341<   defm PACKUSDW : sse4_pack<0x2B, "packusdw", v8i16, v4i32, X86Packus,
1342<                             bc_v4i32>;
1343< }
1344< } // ExeDomain = SSEPackedInt
1345<
1346< //===---------------------------------------------------------------------===//
13477171a7056,7057
1348>   defm VPACKUSDW : SS41I_binop_rm_int<0x2B, "vpackusdw", int_x86_sse41_packusdw,
1349>                                       0, DEFAULT_ITINS_SHUFFLESCHED>, VEX_4V;
13507202a7089,7091
1351>   defm VPACKUSDW : SS41I_binop_rm_int_y<0x2B, "vpackusdw",
1352>                                         int_x86_avx2_packusdw, WriteShuffle>,
1353>                                         VEX_4V, VEX_L;
13547233a7123,7124
1355>   defm PACKUSDW : SS41I_binop_rm_int<0x2B, "packusdw", int_x86_sse41_packusdw,
1356>                                      1, DEFAULT_ITINS_SHUFFLESCHED>;
13578081,8090d7971
1358< class avx_broadcast_no_int<bits<8> opc, string OpcodeStr, RegisterClass RC,
1359<                            X86MemOperand x86memop, ValueType VT,
1360<                            PatFrag ld_frag, SchedWrite Sched> :
1361<   AVX8I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src),
1362<         !strconcat(OpcodeStr, "\t{$src, $dst|$dst, $src}"),
1363<         [(set RC:$dst, (VT (X86VBroadcast (ld_frag addr:$src))))]>,
1364<         Sched<[Sched]>, VEX {
1365<     let mayLoad = 1;
1366< }
1367<
13688099,8102c7980,7983
1369<   def VBROADCASTSSrm  : avx_broadcast_no_int<0x18, "vbroadcastss", VR128,
1370<                                              f32mem, v4f32, loadf32, WriteLoad>;
1371<   def VBROADCASTSSYrm : avx_broadcast_no_int<0x18, "vbroadcastss", VR256,
1372<                                              f32mem, v8f32, loadf32,
1373---
1374>   def VBROADCASTSSrm  : avx_broadcast<0x18, "vbroadcastss", VR128, f32mem,
1375>                                       int_x86_avx_vbroadcast_ss, WriteLoad>;
1376>   def VBROADCASTSSYrm : avx_broadcast<0x18, "vbroadcastss", VR256, f32mem,
1377>                                       int_x86_avx_vbroadcast_ss_256,
13788106,8107c7987,7989
1379< def VBROADCASTSDYrm  : avx_broadcast_no_int<0x19, "vbroadcastsd", VR256, f64mem,
1380<                                     v4f64, loadf64, WriteFShuffleLd>, VEX_L;
1381---
1382> def VBROADCASTSDYrm  : avx_broadcast<0x19, "vbroadcastsd", VR256, f64mem,
1383>                                     int_x86_avx_vbroadcast_sd_256,
1384>                                     WriteFShuffleLd>, VEX_L;
13858663a8546,8552
1386> def : Pat<(v8f32 (X86VBroadcast (loadf32 addr:$src))),
1387>           (VBROADCASTSSYrm addr:$src)>;
1388> def : Pat<(v4f64 (X86VBroadcast (loadf64 addr:$src))),
1389>           (VBROADCASTSDYrm addr:$src)>;
1390> def : Pat<(v4f32 (X86VBroadcast (loadf32 addr:$src))),
1391>           (VBROADCASTSSrm addr:$src)>;
1392>
1393diff -r -b parabix-llvm/lib/Target/X86/X86ISelLowering.cpp r209855/lib/Target/X86/X86ISelLowering.cpp
139422d21
1395< #include "X86ParabixISelLowering.h"
1396213,214d211
1397< extern MVT getFullRegisterType(MVT VT);
1398<
1399298d294
1400<   {
1401300,315d295
1402<   }
1403<
1404<   // Parabix register class
1405<   static const MVT ParabixVTs[] = { MVT::v32i1, MVT::v64i1, MVT::v64i2, MVT::v32i4,
1406<                                     MVT::v128i1 };
1407<   for (unsigned i = 0; i != array_lengthof(ParabixVTs); ++i) {
1408<     if (ParabixVTs[i].is32BitVector()) {
1409<       addRegisterClass(ParabixVTs[i], &X86::GR32XRegClass);
1410<     }
1411<     else if (ParabixVTs[i].is64BitVector() && Subtarget->is64Bit()) {
1412<       addRegisterClass(ParabixVTs[i], &X86::GR64XRegClass);
1413<     }
1414<     else if (ParabixVTs[i].is128BitVector() && Subtarget->hasSSE2()) {
1415<       addRegisterClass(ParabixVTs[i], &X86::VR128PXRegClass);
1416<     }
1417<   }
14181561,1604d1540
1419<   // Should be a good place to put Parabix operations.
1420<   // Like Add on v64i1
1421<   // Clear std::map here.
1422<   resetOperand0Action();
1423<   setOperationAction(ISD::MULHU, MVT::v32i1, Custom);
1424<   if (Subtarget->is64Bit())
1425<       setOperationAction(ISD::MULHU, MVT::v64i1, Custom);
1426<   if (Subtarget->hasSSE2()) {
1427<     setOperationAction(ISD::MUL, MVT::v16i8, Custom);
1428<     setOperationAction(ISD::MULHU, MVT::v128i1, Custom);
1429<   }
1430<
1431<   for (unsigned i = 0; i != array_lengthof(ParabixVTs); ++i) {
1432<     // v64i1 is only added and lowered for 64bit subtarget
1433<     if (ParabixVTs[i].is64BitVector() && !Subtarget->is64Bit())
1434<       continue;
1435<
1436<     setOperationAction(ISD::ADD, ParabixVTs[i], Custom);
1437<     setOperationAction(ISD::SUB, ParabixVTs[i], Custom);
1438<     setOperationAction(ISD::MUL, ParabixVTs[i], Custom);
1439<     setOperationAction(ISD::AND, ParabixVTs[i], Custom);
1440<     setOperationAction(ISD::OR,  ParabixVTs[i], Custom);
1441<     setOperationAction(ISD::XOR, ParabixVTs[i], Custom);
1442<     setOperationAction(ISD::SHL, ParabixVTs[i], Custom);
1443<     setOperationAction(ISD::SRL, ParabixVTs[i], Custom);
1444<     setOperationAction(ISD::SRA, ParabixVTs[i], Custom);
1445<     setOperationAction(ISD::SETCC,              ParabixVTs[i], Custom);
1446<     setOperationAction(ISD::BUILD_VECTOR,       ParabixVTs[i], Custom);
1447<     setOperationAction(ISD::SCALAR_TO_VECTOR,   ParabixVTs[i], Custom);
1448<     setOperationAction(ISD::EXTRACT_VECTOR_ELT, ParabixVTs[i], Custom);
1449<     setOperationAction(ISD::INSERT_VECTOR_ELT,  ParabixVTs[i], Custom);
1450<
1451<     //Better way to lower LOAD/STORE
1452<     setOperationAction(ISD::STORE, ParabixVTs[i], Promote);
1453<     AddPromotedToType (ISD::STORE, ParabixVTs[i], getFullRegisterType(ParabixVTs[i]));
1454<     setOperationAction(ISD::LOAD,  ParabixVTs[i], Promote);
1455<     AddPromotedToType (ISD::LOAD,  ParabixVTs[i], getFullRegisterType(ParabixVTs[i]));
1456<   }
1457<   // Parabix: custom lowering ISD::UADDO for long stream addition.
1458<   // ref: LegalizeDAG.cpp 3693. UADDO is expanded to ADD and SetCC
1459<   // ref: this file, lowerXALUO, UADDO to X86ISD::ADD and SetCC X86::Cond_B
1460<   setTargetDAGCombine(ISD::UADDO);
1461<   setTargetDAGCombine(ISD::UADDE);
1462<
14632326,2327d2261
1464<       else if (RegVT.isParabixVector() && RegVT.is128BitVector())
1465<         RC = &X86::VR128PXRegClass;
14662338,2341d2271
1467<       else if (RegVT == MVT::v32i1)
1468<         RC = &X86::GR32XRegClass;
1469<       else if (RegVT == MVT::v64i1)
1470<         RC = &X86::GR64XRegClass;
14714946d4875
1472<
147312232,12245d12160
1474<   case Intrinsic::x86_sse2_packssdw_128:
1475<   case Intrinsic::x86_sse2_packsswb_128:
1476<   case Intrinsic::x86_avx2_packssdw:
1477<   case Intrinsic::x86_avx2_packsswb:
1478<     return DAG.getNode(X86ISD::PACKSS, dl, Op.getValueType(),
1479<                        Op.getOperand(1), Op.getOperand(2));
1480<
1481<   case Intrinsic::x86_sse2_packuswb_128:
1482<   case Intrinsic::x86_sse41_packusdw:
1483<   case Intrinsic::x86_avx2_packuswb:
1484<   case Intrinsic::x86_avx2_packusdw:
1485<     return DAG.getNode(X86ISD::PACKUS, dl, Op.getValueType(),
1486<                        Op.getOperand(1), Op.getOperand(2));
1487<
148814530,14563d14444
1489<   // Redirect Parabix Operation Lowering
1490<   // TODO: Combine these logic together.
1491<   // SETCC would always return i1 vector, but it may not be parabix op
1492<   if (Op.getOpcode() != ISD::SETCC && Op.getValueType().isParabixVector())
1493<     return LowerParabixOperation(Op, DAG);
1494<   if (Op.getOpcode() == ISD::MUL && Op.getSimpleValueType() == MVT::v16i8)
1495<     return LowerParabixOperation(Op, DAG);
1496<   if (Op.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
1497<       Op.getOperand(0).getValueType().isParabixVector())
1498<     return LowerParabixOperation(Op, DAG);
1499<   if (Op.getOpcode() == ISD::SETCC &&
1500<       Op.getOperand(0).getValueType().isParabixVector())
1501<     return LowerParabixOperation(Op, DAG);
1502<   if (Op.getOpcode() == ISD::VSELECT &&
1503<       Op.getOperand(0).getSimpleValueType() == MVT::v32i1 &&
1504<       Op.getOperand(1).getSimpleValueType() == MVT::v32i8 &&
1505<       Subtarget->hasAVX2()) {
1506<     //for VSELECT, if the mask is v32i1, zext it to v32i8, otherwise
1507<     //it's legal.
1508<     return LowerParabixOperation(Op, DAG);
1509<   }
1510<   if (Op.getOpcode() == ISD::SIGN_EXTEND &&
1511<       Op.getOperand(0).getSimpleValueType() == MVT::v32i1 &&
1512<       Op.getSimpleValueType() == MVT::v32i8 &&
1513<       Subtarget->hasAVX2()) {
1514<     return LowerParabixOperation(Op, DAG);
1515<   }
1516<
1517<   if (Op.getOpcode() == ISD::STORE)
1518<   {
1519<     dbgs() << "Store that are not redirected: \n";
1520<     Op.dumpr();
1521<   }
1522<
152315031,15032d14911
1524<   case X86ISD::PACKSS:             return "X86ISD::PACKSS";
1525<   case X86ISD::PACKUS:             return "X86ISD::PACKUS";
152619640,19646d19518
1527<     // if Memsz is smaller than i8, no bigger interger type would devides the total
1528<     // loaded size. e.g. MemVT = v4i1, RegVT= v4i32, Numloads will be zero.
1529<     if (MemSz % SclrLoadTy.getSizeInBits() != 0) {
1530<       //Can't find such a scalar type
1531<       return SDValue();
1532<     }
1533<
153420713,20718d20584
1535<   //Parabix
1536<   //Redirect to Parabix combine logic first. If nothing changed, go over the
1537<   //original combine logic.
1538<   SDValue R = PerformParabixDAGCombine(N, DCI);
1539<   if (R.getNode()) return R;
1540<
1541diff -r -b parabix-llvm/lib/Target/X86/X86ISelLowering.h r209855/lib/Target/X86/X86ISelLowering.h
1542318,319d317
1543<       PACKSS,
1544<       PACKUS,
1545590,592d587
1546<     /// LowerParabixOperation
1547<     SDValue LowerParabixOperation(SDValue Op, SelectionDAG &DAG) const;
1548<
1549602,603d596
1550<     SDValue PerformParabixDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
1551<
1552893d885
1553<     SDValue PXLowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
1554Only in parabix-llvm/lib/Target/X86: X86ParabixISelLowering.cpp
1555Only in parabix-llvm/lib/Target/X86: X86ParabixISelLowering.h
1556diff -r -b parabix-llvm/lib/Target/X86/X86RegisterInfo.td r209855/lib/Target/X86/X86RegisterInfo.td
1557335,339d334
1558< // GR32 Extended, used for parabix
1559< def GR32X : RegisterClass<"X86", [v32i1, i32], 32,
1560<                          (add EAX, ECX, EDX, ESI, EDI, EBX, EBP, ESP,
1561<                               R8D, R9D, R10D, R11D, R14D, R15D, R12D, R13D)>;
1562<
1563347,351d341
1564< // GR64 Extended, used for parabix
1565< def GR64X : RegisterClass<"X86", [v64i1, i64], 64,
1566<                          (add RAX, RCX, RDX, RSI, RDI, R8, R9, R10, R11,
1567<                               RBX, R14, R15, R12, R13, RBP, RSP, RIP)>;
1568<
1569450,454d439
1570<
1571< // Parabix
1572< def VR128PX : RegisterClass<"X86", [v128i1, v64i2, v32i4, v16i8, v8i16,
1573<                                     v4i32, v2i64, v4f32, v2f64],
1574<                             128, (add FR32)>;
1575diff -r -b parabix-llvm/lib/Transforms/InstCombine/InstructionCombining.cpp r209855/lib/Transforms/InstCombine/InstructionCombining.cpp
15761236,1238d1235
1577<       // Keep track of the type as we walk the GEP.
1578<       Type *CurTy = Op1->getOperand(0)->getType()->getScalarType();
1579<
15801251c1248,1253
1581<             if (J > 1 && CurTy->isStructTy())
1582---
1583>             if (J > 1) {
1584>               SmallVector<Value*, 8> Idxs(GEP.idx_begin(), GEP.idx_begin()+J-1);
1585>               Type *Ty =
1586>                 GetElementPtrInst::getIndexedType(Op1->getOperand(0)->getType(),
1587>                                                   Idxs);
1588>               if (Ty->isStructTy())
15891252a1255
1590>             }
15911263,1271d1265
1592<           }
1593<         }
1594<
1595<         // Sink down a layer of the type for the next iteration.
1596<         if (J > 0) {
1597<           if (CompositeType *CT = dyn_cast<CompositeType>(CurTy)) {
1598<             CurTy = CT->getTypeAtIndex(Op1->getOperand(J));
1599<           } else {
1600<             CurTy = nullptr;
1601diff -r -b parabix-llvm/lib/Transforms/IPO/FunctionAttrs.cpp r209855/lib/Transforms/IPO/FunctionAttrs.cpp
1602452,463d451
1603<       bool Captures = true;
1604<
1605<       if (I->getType()->isVoidTy())
1606<         Captures = false;
1607<
1608<       auto AddUsersToWorklistIfCapturing = [&] {
1609<         if (Captures)
1610<           for (Use &UU : I->uses())
1611<             if (Visited.insert(&UU))
1612<               Worklist.push_back(&UU);
1613<       };
1614<
1615465,466c453
1616<       if (CS.doesNotAccessMemory()) {
1617<         AddUsersToWorklistIfCapturing();
1618---
1619>       if (CS.doesNotAccessMemory())
1620468d454
1621<       }
1622474d459
1623<           AddUsersToWorklistIfCapturing();
1624489d473
1625<           Captures &= !CS.doesNotCapture(A - B);
1626498d481
1627<       AddUsersToWorklistIfCapturing();
1628Only in parabix-llvm: README.md
1629diff -r -b parabix-llvm/test/CodeGen/X86/avx-intrinsics-x86.ll r209855/test/CodeGen/X86/avx-intrinsics-x86.ll
16302221a2222,2229
1631> define <4 x double> @test_x86_avx_vbroadcast_sd_256(i8* %a0) {
1632>   ; CHECK: vbroadcastsd
1633>   %res = call <4 x double> @llvm.x86.avx.vbroadcast.sd.256(i8* %a0) ; <<4 x double>> [#uses=1]
1634>   ret <4 x double> %res
1635> }
1636> declare <4 x double> @llvm.x86.avx.vbroadcast.sd.256(i8*) nounwind readonly
1637>
1638>
16392235a2244,2259
1640>
1641>
1642> define <4 x float> @test_x86_avx_vbroadcast_ss(i8* %a0) {
1643>   ; CHECK: vbroadcastss
1644>   %res = call <4 x float> @llvm.x86.avx.vbroadcast.ss(i8* %a0) ; <<4 x float>> [#uses=1]
1645>   ret <4 x float> %res
1646> }
1647> declare <4 x float> @llvm.x86.avx.vbroadcast.ss(i8*) nounwind readonly
1648>
1649>
1650> define <8 x float> @test_x86_avx_vbroadcast_ss_256(i8* %a0) {
1651>   ; CHECK: vbroadcastss
1652>   %res = call <8 x float> @llvm.x86.avx.vbroadcast.ss.256(i8* %a0) ; <<8 x float>> [#uses=1]
1653>   ret <8 x float> %res
1654> }
1655> declare <8 x float> @llvm.x86.avx.vbroadcast.ss.256(i8*) nounwind readonly
1656Only in parabix-llvm/test/CodeGen/X86: x86-upgrade-avx-vbroadcast.ll
1657Only in parabix-llvm/test: Parabix
1658diff -r -b parabix-llvm/test/TableGen/intrinsic-varargs.td r209855/test/TableGen/intrinsic-varargs.td
165926c26
1660< def isVoid : ValueType<0, 104>;   // Produces no value
1661---
1662> def isVoid : ValueType<0, 56>;   // Produces no value
1663diff -r -b parabix-llvm/test/Transforms/FunctionAttrs/nocapture.ll r209855/test/Transforms/FunctionAttrs/nocapture.ll
166471c71
1665< ; CHECK: define i1 @c7(i32* readonly %q, i32 %bitno)
1666---
1667> ; CHECK: define i1 @c7(i32* readnone %q, i32 %bitno)
1668diff -r -b parabix-llvm/test/Transforms/FunctionAttrs/readattrs.ll r209855/test/Transforms/FunctionAttrs/readattrs.ll
166954,67d53
1670<
1671< ; CHECK: define i32* @test8_1(i32* readnone %p)
1672< define i32* @test8_1(i32* %p) {
1673< entry:
1674<   ret i32* %p
1675< }
1676<
1677< ; CHECK: define void @test8_2(i32* %p)
1678< define void @test8_2(i32* %p) {
1679< entry:
1680<   %call = call i32* @test8_1(i32* %p)
1681<   store i32 10, i32* %call, align 4
1682<   ret void
1683< }
1684diff -r -b parabix-llvm/tools/CMakeLists.txt r209855/tools/CMakeLists.txt
168572c72
1686< #add_llvm_external_project(clang)
1687---
1688> add_llvm_external_project(clang)
1689diff -r -b parabix-llvm/tools/llc/llc.cpp r209855/tools/llc/llc.cpp
1690179,180d178
1691<   dbgs() << "WARN: Meng's build of llc running...\n";
1692<
1693diff -r -b parabix-llvm/utils/TableGen/CodeGenTarget.cpp r209855/utils/TableGen/CodeGenTarget.cpp
169455,56d54
1695<   case MVT::i2:     return "MVT::i2";
1696<   case MVT::i4:     return "MVT::i4";
169762,65d59
1698<   case MVT::i256:     return "MVT::i256";
1699<   case MVT::i512:     return "MVT::i512";
1700<   case MVT::i1024:     return "MVT::i1024";
1701<
170278d71
1703<   case MVT::v1i1:     return "MVT::v1i1";
170485,107d77
1705<   case MVT::v128i1:     return "MVT::v128i1";
1706<   case MVT::v256i1:     return "MVT::v256i1";
1707<   case MVT::v512i1:     return "MVT::v512i1";
1708<   case MVT::v1024i1:     return "MVT::v1024i1";
1709<   case MVT::v1i2:     return "MVT::v1i2";
1710<   case MVT::v2i2:     return "MVT::v2i2";
1711<   case MVT::v4i2:     return "MVT::v4i2";
1712<   case MVT::v8i2:     return "MVT::v8i2";
1713<   case MVT::v16i2:     return "MVT::v16i2";
1714<   case MVT::v32i2:     return "MVT::v32i2";
1715<   case MVT::v64i2:     return "MVT::v64i2";
1716<   case MVT::v128i2:     return "MVT::v128i2";
1717<   case MVT::v256i2:     return "MVT::v256i2";
1718<   case MVT::v512i2:     return "MVT::v512i2";
1719<   case MVT::v1i4:     return "MVT::v1i4";
1720<   case MVT::v2i4:     return "MVT::v2i4";
1721<   case MVT::v4i4:     return "MVT::v4i4";
1722<   case MVT::v8i4:     return "MVT::v8i4";
1723<   case MVT::v16i4:     return "MVT::v16i4";
1724<   case MVT::v32i4:     return "MVT::v32i4";
1725<   case MVT::v64i4:     return "MVT::v64i4";
1726<   case MVT::v128i4:     return "MVT::v128i4";
1727<   case MVT::v256i4:     return "MVT::v256i4";
1728115d84
1729<   case MVT::v128i8:     return "MVT::v128i8";
1730122d90
1731<   case MVT::v64i16:     return "MVT::v64i16";
1732128d95
1733<   case MVT::v32i32:     return "MVT::v32i32";
1734134,145d100
1735<   case MVT::v1i128:     return "MVT::v1i128";
1736<   case MVT::v2i128:     return "MVT::v2i128";
1737<   case MVT::v4i128:     return "MVT::v4i128";
1738<   case MVT::v8i128:     return "MVT::v8i128";
1739<   case MVT::v1i256:     return "MVT::v1i256";
1740<   case MVT::v2i256:     return "MVT::v2i256";
1741<   case MVT::v4i256:     return "MVT::v4i256";
1742<   case MVT::v1i512:     return "MVT::v1i512";
1743<   case MVT::v2i512:     return "MVT::v2i512";
1744<   case MVT::v1i1024:     return "MVT::v1i1024";
1745<
1746<   case MVT::v1f16:     return "MVT::v1f16";
1747149,151d103
1748<   case MVT::v16f16:     return "MVT::v16f16";
1749<   case MVT::v32f16:     return "MVT::v32f16";
1750<   case MVT::v64f16:     return "MVT::v64f16";
1751157d108
1752<   case MVT::v32f32:     return "MVT::v32f32";
1753162,163d112
1754<   case MVT::v16f64:     return "MVT::v16f64";
1755<
1756diff -r -b parabix-llvm/utils/vim/llvm.vim r209855/utils/vim/llvm.vim
17574c4
1758< " Version:      $Revision$
1759---
1760> " Version:      $Revision: 203866 $
1761diff -r -b parabix-llvm/utils/vim/tablegen.vim r209855/utils/vim/tablegen.vim
17624c4
1763< " Version:    $Revision$
1764---
1765> " Version:    $Revision: 151164 $
1766diff -r -b parabix-llvm/utils/vim/vimrc r209855/utils/vim/vimrc
17672c2
1768< " $Revision$
1769---
1770> " $Revision: 176235 $
Note: See TracBrowser for help on using the repository browser.