Add a missing cast for Neon vsbl results.
[oota-llvm.git] / utils / TableGen / NeonEmitter.cpp
1 //===- NeonEmitter.cpp - Generate arm_neon.h for use with clang -*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This tablegen backend is responsible for emitting arm_neon.h, which includes
11 // a declaration and definition of each function specified by the ARM NEON 
12 // compiler interface.  See ARM document DUI0348B.
13 //
14 // Each NEON instruction is implemented in terms of 1 or more functions which
15 // are suffixed with the element type of the input vectors.  Functions may be 
16 // implemented in terms of generic vector operations such as +, *, -, etc. or
17 // by calling a __builtin_-prefixed function which will be handled by clang's
18 // CodeGen library.
19 //
20 // Additional validation code can be generated by this file when runHeader() is
21 // called, rather than the normal run() entry point.
22 //
23 //===----------------------------------------------------------------------===//
24
25 #include "NeonEmitter.h"
26 #include "llvm/ADT/SmallString.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/ADT/StringExtras.h"
29 #include <string>
30
31 using namespace llvm;
32
33 /// ParseTypes - break down a string such as "fQf" into a vector of StringRefs,
34 /// which each StringRef representing a single type declared in the string.
35 /// for "fQf" we would end up with 2 StringRefs, "f", and "Qf", representing
36 /// 2xfloat and 4xfloat respectively.
37 static void ParseTypes(Record *r, std::string &s,
38                        SmallVectorImpl<StringRef> &TV) {
39   const char *data = s.data();
40   int len = 0;
41   
42   for (unsigned i = 0, e = s.size(); i != e; ++i, ++len) {
43     if (data[len] == 'P' || data[len] == 'Q' || data[len] == 'U')
44       continue;
45     
46     switch (data[len]) {
47       case 'c':
48       case 's':
49       case 'i':
50       case 'l':
51       case 'h':
52       case 'f':
53         break;
54       default:
55         throw TGError(r->getLoc(),
56                       "Unexpected letter: " + std::string(data + len, 1));
57         break;
58     }
59     TV.push_back(StringRef(data, len + 1));
60     data += len + 1;
61     len = -1;
62   }
63 }
64
65 /// Widen - Convert a type code into the next wider type.  char -> short,
66 /// short -> int, etc.
67 static char Widen(const char t) {
68   switch (t) {
69     case 'c':
70       return 's';
71     case 's':
72       return 'i';
73     case 'i':
74       return 'l';
75     default: throw "unhandled type in widen!";
76   }
77   return '\0';
78 }
79
80 /// Narrow - Convert a type code into the next smaller type.  short -> char,
81 /// float -> half float, etc.
82 static char Narrow(const char t) {
83   switch (t) {
84     case 's':
85       return 'c';
86     case 'i':
87       return 's';
88     case 'l':
89       return 'i';
90     case 'f':
91       return 'h';
92     default: throw "unhandled type in narrow!";
93   }
94   return '\0';
95 }
96
97 /// For a particular StringRef, return the base type code, and whether it has
98 /// the quad-vector, polynomial, or unsigned modifiers set.
99 static char ClassifyType(StringRef ty, bool &quad, bool &poly, bool &usgn) {
100   unsigned off = 0;
101   
102   // remember quad.
103   if (ty[off] == 'Q') {
104     quad = true;
105     ++off;
106   }
107   
108   // remember poly.
109   if (ty[off] == 'P') {
110     poly = true;
111     ++off;
112   }
113   
114   // remember unsigned.
115   if (ty[off] == 'U') {
116     usgn = true;
117     ++off;
118   }
119   
120   // base type to get the type string for.
121   return ty[off];
122 }
123
124 /// ModType - Transform a type code and its modifiers based on a mod code. The
125 /// mod code definitions may be found at the top of arm_neon.td.
126 static char ModType(const char mod, char type, bool &quad, bool &poly,
127                     bool &usgn, bool &scal, bool &cnst, bool &pntr) {
128   switch (mod) {
129     case 't':
130       if (poly) {
131         poly = false;
132         usgn = true;
133       }
134       break;
135     case 'u':
136       usgn = true;
137       poly = false;
138       if (type == 'f')
139         type = 'i';
140       break;
141     case 'x':
142       usgn = false;
143       poly = false;
144       if (type == 'f')
145         type = 'i';
146       break;
147     case 'f':
148       if (type == 'h')
149         quad = true;
150       type = 'f';
151       usgn = false;
152       break;
153     case 'g':
154       quad = false;
155       break;
156     case 'w':
157       type = Widen(type);
158       quad = true;
159       break;
160     case 'n':
161       type = Widen(type);
162       break;
163     case 'i':
164       type = 'i';
165       scal = true;
166       break;
167     case 'l':
168       type = 'l';
169       scal = true;
170       usgn = true;
171       break;
172     case 's':
173     case 'a':
174       scal = true;
175       break;
176     case 'k':
177       quad = true;
178       break;
179     case 'c':
180       cnst = true;
181     case 'p':
182       pntr = true;
183       scal = true;
184       break;
185     case 'h':
186       type = Narrow(type);
187       if (type == 'h')
188         quad = false;
189       break;
190     case 'e':
191       type = Narrow(type);
192       usgn = true;
193       break;
194     default:
195       break;
196   }
197   return type;
198 }
199
200 /// TypeString - for a modifier and type, generate the name of the typedef for
201 /// that type.  QUc -> uint8x8_t.
202 static std::string TypeString(const char mod, StringRef typestr) {
203   bool quad = false;
204   bool poly = false;
205   bool usgn = false;
206   bool scal = false;
207   bool cnst = false;
208   bool pntr = false;
209   
210   if (mod == 'v')
211     return "void";
212   if (mod == 'i')
213     return "int";
214   
215   // base type to get the type string for.
216   char type = ClassifyType(typestr, quad, poly, usgn);
217   
218   // Based on the modifying character, change the type and width if necessary.
219   type = ModType(mod, type, quad, poly, usgn, scal, cnst, pntr);
220   
221   SmallString<128> s;
222   
223   if (usgn)
224     s.push_back('u');
225   
226   switch (type) {
227     case 'c':
228       s += poly ? "poly8" : "int8";
229       if (scal)
230         break;
231       s += quad ? "x16" : "x8";
232       break;
233     case 's':
234       s += poly ? "poly16" : "int16";
235       if (scal)
236         break;
237       s += quad ? "x8" : "x4";
238       break;
239     case 'i':
240       s += "int32";
241       if (scal)
242         break;
243       s += quad ? "x4" : "x2";
244       break;
245     case 'l':
246       s += "int64";
247       if (scal)
248         break;
249       s += quad ? "x2" : "x1";
250       break;
251     case 'h':
252       s += "float16";
253       if (scal)
254         break;
255       s += quad ? "x8" : "x4";
256       break;
257     case 'f':
258       s += "float32";
259       if (scal)
260         break;
261       s += quad ? "x4" : "x2";
262       break;
263     default:
264       throw "unhandled type!";
265       break;
266   }
267
268   if (mod == '2')
269     s += "x2";
270   if (mod == '3')
271     s += "x3";
272   if (mod == '4')
273     s += "x4";
274   
275   // Append _t, finishing the type string typedef type.
276   s += "_t";
277   
278   if (cnst)
279     s += " const";
280   
281   if (pntr)
282     s += " *";
283   
284   return s.str();
285 }
286
287 /// BuiltinTypeString - for a modifier and type, generate the clang
288 /// BuiltinsARM.def prototype code for the function.  See the top of clang's
289 /// Builtins.def for a description of the type strings.
290 static std::string BuiltinTypeString(const char mod, StringRef typestr,
291                                      ClassKind ck, bool ret) {
292   bool quad = false;
293   bool poly = false;
294   bool usgn = false;
295   bool scal = false;
296   bool cnst = false;
297   bool pntr = false;
298   
299   if (mod == 'v')
300     return "v"; // void
301   if (mod == 'i')
302     return "i"; // int
303   
304   // base type to get the type string for.
305   char type = ClassifyType(typestr, quad, poly, usgn);
306   
307   // Based on the modifying character, change the type and width if necessary.
308   type = ModType(mod, type, quad, poly, usgn, scal, cnst, pntr);
309
310   // All pointers are void* pointers.  Change type to 'v' now.
311   if (pntr) {
312     usgn = false;
313     poly = false;
314     type = 'v';
315   }
316   // Treat half-float ('h') types as unsigned short ('s') types.
317   if (type == 'h') {
318     type = 's';
319     usgn = true;
320   }
321   usgn = usgn | poly | ((ck == ClassI || ck == ClassW) && scal && type != 'f');
322
323   if (scal) {
324     SmallString<128> s;
325
326     if (usgn)
327       s.push_back('U');
328     else if (type == 'c')
329       s.push_back('S'); // make chars explicitly signed
330     
331     if (type == 'l') // 64-bit long
332       s += "LLi";
333     else
334       s.push_back(type);
335  
336     if (cnst)
337       s.push_back('C');
338     if (pntr)
339       s.push_back('*');
340     return s.str();
341   }
342
343   // Since the return value must be one type, return a vector type of the
344   // appropriate width which we will bitcast.  An exception is made for
345   // returning structs of 2, 3, or 4 vectors which are returned in a sret-like
346   // fashion, storing them to a pointer arg.
347   if (ret) {
348     if (mod >= '2' && mod <= '4')
349       return "vv*"; // void result with void* first argument
350     if (mod == 'f' || (ck != ClassB && type == 'f'))
351       return quad ? "V4f" : "V2f";
352     if (ck != ClassB && type == 's')
353       return quad ? "V8s" : "V4s";
354     if (ck != ClassB && type == 'i')
355       return quad ? "V4i" : "V2i";
356     if (ck != ClassB && type == 'l')
357       return quad ? "V2LLi" : "V1LLi";
358     
359     return quad ? "V16Sc" : "V8Sc";
360   }    
361
362   // Non-return array types are passed as individual vectors.
363   if (mod == '2')
364     return quad ? "V16ScV16Sc" : "V8ScV8Sc";
365   if (mod == '3')
366     return quad ? "V16ScV16ScV16Sc" : "V8ScV8ScV8Sc";
367   if (mod == '4')
368     return quad ? "V16ScV16ScV16ScV16Sc" : "V8ScV8ScV8ScV8Sc";
369
370   if (mod == 'f' || (ck != ClassB && type == 'f'))
371     return quad ? "V4f" : "V2f";
372   if (ck != ClassB && type == 's')
373     return quad ? "V8s" : "V4s";
374   if (ck != ClassB && type == 'i')
375     return quad ? "V4i" : "V2i";
376   if (ck != ClassB && type == 'l')
377     return quad ? "V2LLi" : "V1LLi";
378   
379   return quad ? "V16Sc" : "V8Sc";
380 }
381
382 /// MangleName - Append a type or width suffix to a base neon function name, 
383 /// and insert a 'q' in the appropriate location if the operation works on
384 /// 128b rather than 64b.   E.g. turn "vst2_lane" into "vst2q_lane_f32", etc.
385 static std::string MangleName(const std::string &name, StringRef typestr,
386                               ClassKind ck) {
387   if (name == "vcvt_f32_f16")
388     return name;
389   
390   bool quad = false;
391   bool poly = false;
392   bool usgn = false;
393   char type = ClassifyType(typestr, quad, poly, usgn);
394
395   std::string s = name;
396   
397   switch (type) {
398   case 'c':
399     switch (ck) {
400     case ClassS: s += poly ? "_p8" : usgn ? "_u8" : "_s8"; break;
401     case ClassI: s += "_i8"; break;
402     case ClassW: s += "_8"; break;
403     default: break;
404     }
405     break;
406   case 's':
407     switch (ck) {
408     case ClassS: s += poly ? "_p16" : usgn ? "_u16" : "_s16"; break;
409     case ClassI: s += "_i16"; break;
410     case ClassW: s += "_16"; break;
411     default: break;
412     }
413     break;
414   case 'i':
415     switch (ck) {
416     case ClassS: s += usgn ? "_u32" : "_s32"; break;
417     case ClassI: s += "_i32"; break;
418     case ClassW: s += "_32"; break;
419     default: break;
420     }
421     break;
422   case 'l':
423     switch (ck) {
424     case ClassS: s += usgn ? "_u64" : "_s64"; break;
425     case ClassI: s += "_i64"; break;
426     case ClassW: s += "_64"; break;
427     default: break;
428     }
429     break;
430   case 'h':
431     switch (ck) {
432     case ClassS:
433     case ClassI: s += "_f16"; break;
434     case ClassW: s += "_16"; break;
435     default: break;
436     }
437     break;
438   case 'f':
439     switch (ck) {
440     case ClassS:
441     case ClassI: s += "_f32"; break;
442     case ClassW: s += "_32"; break;
443     default: break;
444     }
445     break;
446   default:
447     throw "unhandled type!";
448     break;
449   }
450   if (ck == ClassB)
451     s += "_v";
452     
453   // Insert a 'q' before the first '_' character so that it ends up before 
454   // _lane or _n on vector-scalar operations.
455   if (quad) {
456     size_t pos = s.find('_');
457     s = s.insert(pos, "q");
458   }
459   return s;
460 }
461
462 // Generate the string "(argtype a, argtype b, ...)"
463 static std::string GenArgs(const std::string &proto, StringRef typestr) {
464   bool define = proto.find('i') != std::string::npos;
465   char arg = 'a';
466   
467   std::string s;
468   s += "(";
469   
470   for (unsigned i = 1, e = proto.size(); i != e; ++i, ++arg) {
471     if (!define) {
472       s += TypeString(proto[i], typestr);
473       s.push_back(' ');
474     }
475     s.push_back(arg);
476     if ((i + 1) < e)
477       s += ", ";
478   }
479   
480   s += ")";
481   return s;
482 }
483
484 static std::string Duplicate(unsigned nElts, StringRef typestr, 
485                              const std::string &a) {
486   std::string s;
487   
488   s = "(" + TypeString('d', typestr) + "){ ";
489   for (unsigned i = 0; i != nElts; ++i) {
490     s += a;
491     if ((i + 1) < nElts)
492       s += ", ";
493   }
494   s += " }";
495   
496   return s;
497 }
498
499 static unsigned GetNumElements(StringRef typestr, bool &quad) {
500   quad = false;
501   bool dummy = false;
502   char type = ClassifyType(typestr, quad, dummy, dummy);
503   unsigned nElts = 0;
504   switch (type) {
505   case 'c': nElts = 8; break;
506   case 's': nElts = 4; break;
507   case 'i': nElts = 2; break;
508   case 'l': nElts = 1; break;
509   case 'h': nElts = 4; break;
510   case 'f': nElts = 2; break;
511   default:
512     throw "unhandled type!";
513     break;
514   }
515   if (quad) nElts <<= 1;
516   return nElts;
517 }
518
519 // Generate the definition for this intrinsic, e.g. "a + b" for OpAdd.
520 static std::string GenOpString(OpKind op, const std::string &proto,
521                                StringRef typestr) {
522   bool quad;
523   unsigned nElts = GetNumElements(typestr, quad);
524   
525   std::string ts = TypeString(proto[0], typestr);
526   std::string s;
527   if (op == OpHi || op == OpLo) {
528     s = "union { " + ts + " r; double d; } u; u.d";
529   } else {
530     s = ts + " r; r";
531   }
532   
533   s += " = ";
534
535   switch(op) {
536   case OpAdd:
537     s += "a + b";
538     break;
539   case OpSub:
540     s += "a - b";
541     break;
542   case OpMulN:
543     s += "a * " + Duplicate(nElts, typestr, "b");
544     break;
545   case OpMul:
546     s += "a * b";
547     break;
548   case OpMlaN:
549     s += "a + (b * " + Duplicate(nElts, typestr, "c") + ")";
550     break;
551   case OpMla:
552     s += "a + (b * c)";
553     break;
554   case OpMlsN:
555     s += "a - (b * " + Duplicate(nElts, typestr, "c") + ")";
556     break;
557   case OpMls:
558     s += "a - (b * c)";
559     break;
560   case OpEq:
561     s += "(" + ts + ")(a == b)";
562     break;
563   case OpGe:
564     s += "(" + ts + ")(a >= b)";
565     break;
566   case OpLe:
567     s += "(" + ts + ")(a <= b)";
568     break;
569   case OpGt:
570     s += "(" + ts + ")(a > b)";
571     break;
572   case OpLt:
573     s += "(" + ts + ")(a < b)";
574     break;
575   case OpNeg:
576     s += " -a";
577     break;
578   case OpNot:
579     s += " ~a";
580     break;
581   case OpAnd:
582     s += "a & b";
583     break;
584   case OpOr:
585     s += "a | b";
586     break;
587   case OpXor:
588     s += "a ^ b";
589     break;
590   case OpAndNot:
591     s += "a & ~b";
592     break;
593   case OpOrNot:
594     s += "a | ~b";
595     break;
596   case OpCast:
597     s += "(" + ts + ")a";
598     break;
599   case OpConcat:
600     s += "(" + ts + ")__builtin_shufflevector((int64x1_t)a";
601     s += ", (int64x1_t)b, 0, 1)";
602     break;
603   case OpHi:
604     s += "(((float64x2_t)a)[1])";
605     break;
606   case OpLo:
607     s += "(((float64x2_t)a)[0])";
608     break;
609   case OpDup:
610     s += Duplicate(nElts, typestr, "a");
611     break;
612   case OpSelect:
613     // ((0 & 1) | (~0 & 2))
614     s += "(" + ts + ")";
615     ts = TypeString(proto[1], typestr);
616     s += "((a & (" + ts + ")b) | ";
617     s += "(~a & (" + ts + ")c))";
618     break;
619   case OpRev16:
620     s += "__builtin_shufflevector(a, a";
621     for (unsigned i = 2; i <= nElts; i += 2)
622       for (unsigned j = 0; j != 2; ++j)
623         s += ", " + utostr(i - j - 1);
624     s += ")";
625     break;
626   case OpRev32: {
627     unsigned WordElts = nElts >> (1 + (int)quad);
628     s += "__builtin_shufflevector(a, a";
629     for (unsigned i = WordElts; i <= nElts; i += WordElts)
630       for (unsigned j = 0; j != WordElts; ++j)
631         s += ", " + utostr(i - j - 1);
632     s += ")";
633     break;
634   }
635   case OpRev64: {
636     unsigned DblWordElts = nElts >> (int)quad;
637     s += "__builtin_shufflevector(a, a";
638     for (unsigned i = DblWordElts; i <= nElts; i += DblWordElts)
639       for (unsigned j = 0; j != DblWordElts; ++j)
640         s += ", " + utostr(i - j - 1);
641     s += ")";
642     break;
643   }
644   default:
645     throw "unknown OpKind!";
646     break;
647   }
648   if (op == OpHi || op == OpLo)
649     s += "; return u.r;";
650   else
651     s += "; return r;";
652   return s;
653 }
654
655 static unsigned GetNeonEnum(const std::string &proto, StringRef typestr) {
656   unsigned mod = proto[0];
657   unsigned ret = 0;
658
659   if (mod == 'v' || mod == 'f')
660     mod = proto[1];
661
662   bool quad = false;
663   bool poly = false;
664   bool usgn = false;
665   bool scal = false;
666   bool cnst = false;
667   bool pntr = false;
668   
669   // Base type to get the type string for.
670   char type = ClassifyType(typestr, quad, poly, usgn);
671   
672   // Based on the modifying character, change the type and width if necessary.
673   type = ModType(mod, type, quad, poly, usgn, scal, cnst, pntr);
674
675   if (usgn)
676     ret |= 0x08;
677   if (quad && proto[1] != 'g')
678     ret |= 0x10;
679   
680   switch (type) {
681     case 'c': 
682       ret |= poly ? 5 : 0;
683       break;
684     case 's':
685       ret |= poly ? 6 : 1;
686       break;
687     case 'i':
688       ret |= 2;
689       break;
690     case 'l':
691       ret |= 3;
692       break;
693     case 'h':
694       ret |= 7;
695       break;
696     case 'f':
697       ret |= 4;
698       break;
699     default:
700       throw "unhandled type!";
701       break;
702   }
703   return ret;
704 }
705
706 // Generate the definition for this intrinsic, e.g. __builtin_neon_cls(a)
707 static std::string GenBuiltin(const std::string &name, const std::string &proto,
708                               StringRef typestr, ClassKind ck) {
709   char arg = 'a';
710   std::string s;
711
712   // If this builtin returns a struct 2, 3, or 4 vectors, pass it as an implicit
713   // sret-like argument.
714   bool sret = (proto[0] >= '2' && proto[0] <= '4');
715
716   // If this builtin takes an immediate argument, we need to #define it rather
717   // than use a standard declaration, so that SemaChecking can range check
718   // the immediate passed by the user.
719   bool define = proto.find('i') != std::string::npos;
720
721   // Check if the prototype has a scalar operand with the type of the vector
722   // elements.  If not, bitcasting the args will take care of arg checking.
723   // The actual signedness etc. will be taken care of with special enums.
724   if (proto.find('s') == std::string::npos)
725     ck = ClassB;
726
727   if (proto[0] != 'v') {
728     std::string ts = TypeString(proto[0], typestr);
729     
730     if (define) {
731       if (sret)
732         s += "({ " + ts + " r; ";
733       else
734         s += "(" + ts + ")";
735     } else if (sret) {
736       s += ts + " r; ";
737     } else {
738       s += ts + " r; r = (" + ts + ")";
739     }
740   }
741   
742   bool splat = proto.find('a') != std::string::npos;
743   
744   s += "__builtin_neon_";
745   if (splat) {
746     // Call the non-splat builtin: chop off the "_n" suffix from the name.
747     std::string vname(name, 0, name.size()-2);
748     s += MangleName(vname, typestr, ck);
749   } else {
750     s += MangleName(name, typestr, ck);
751   }
752   s += "(";
753
754   // Pass the address of the return variable as the first argument to sret-like
755   // builtins.
756   if (sret)
757     s += "&r, ";
758   
759   for (unsigned i = 1, e = proto.size(); i != e; ++i, ++arg) {
760     std::string args = std::string(&arg, 1);
761
762     // Wrap macro arguments in parenthesis.
763     if (define)
764       args = "(" + args + ")";
765
766     bool argQuad = false;
767     bool argPoly = false;
768     bool argUsgn = false;
769     bool argScalar = false;
770     bool dummy = false;
771     char argType = ClassifyType(typestr, argQuad, argPoly, argUsgn);
772     argType = ModType(proto[i], argType, argQuad, argPoly, argUsgn, argScalar,
773                       dummy, dummy);
774
775     // Handle multiple-vector values specially, emitting each subvector as an
776     // argument to the __builtin.
777     if (proto[i] >= '2' && proto[i] <= '4') {
778       // Check if an explicit cast is needed.
779       if (argType != 'c' || argPoly || argUsgn)
780         args = (argQuad ? "(int8x16_t)" : "(int8x8_t)") + args;
781
782       for (unsigned vi = 0, ve = proto[i] - '0'; vi != ve; ++vi) {
783         s += args + ".val[" + utostr(vi) + "]";
784         if ((vi + 1) < ve)
785           s += ", ";
786       }
787       if ((i + 1) < e)
788         s += ", ";
789
790       continue;
791     }
792     
793     // Check if an explicit cast is needed.
794     if (!argScalar &&
795         ((ck == ClassB && argType != 'c') || argPoly || argUsgn)) {
796       std::string argTypeStr = "c";
797       if (ck != ClassB)
798         argTypeStr = argType;
799       if (argQuad)
800         argTypeStr = "Q" + argTypeStr;
801       args = "(" + TypeString('d', argTypeStr) + ")" + args;
802     }
803     
804     if (splat && (i + 1) == e)
805       s += Duplicate(GetNumElements(typestr, argQuad), typestr, args);
806     else
807       s += args;
808     if ((i + 1) < e)
809       s += ", ";
810   }
811   
812   // Extra constant integer to hold type class enum for this function, e.g. s8
813   if (ck == ClassB)
814     s += ", " + utostr(GetNeonEnum(proto, typestr));
815   
816   if (define)
817     s += ")";
818   else
819     s += ");";
820
821   if (proto[0] != 'v') {
822     if (define) {
823       if (sret)
824         s += "; r; })";
825     } else {
826       s += " return r;";
827     }
828   }
829   return s;
830 }
831
832 static std::string GenBuiltinDef(const std::string &name, 
833                                  const std::string &proto,
834                                  StringRef typestr, ClassKind ck) {
835   std::string s("BUILTIN(__builtin_neon_");
836
837   // If all types are the same size, bitcasting the args will take care 
838   // of arg checking.  The actual signedness etc. will be taken care of with
839   // special enums.
840   if (proto.find('s') == std::string::npos)
841     ck = ClassB;
842   
843   s += MangleName(name, typestr, ck);
844   s += ", \"";
845   
846   for (unsigned i = 0, e = proto.size(); i != e; ++i)
847     s += BuiltinTypeString(proto[i], typestr, ck, i == 0);
848
849   // Extra constant integer to hold type class enum for this function, e.g. s8
850   if (ck == ClassB)
851     s += "i";
852   
853   s += "\", \"n\")";
854   return s;
855 }
856
857 /// run - Read the records in arm_neon.td and output arm_neon.h.  arm_neon.h
858 /// is comprised of type definitions and function declarations.
859 void NeonEmitter::run(raw_ostream &OS) {
860   EmitSourceFileHeader("ARM NEON Header", OS);
861   
862   // FIXME: emit license into file?
863   
864   OS << "#ifndef __ARM_NEON_H\n";
865   OS << "#define __ARM_NEON_H\n\n";
866   
867   OS << "#ifndef __ARM_NEON__\n";
868   OS << "#error \"NEON support not enabled\"\n";
869   OS << "#endif\n\n";
870
871   OS << "#include <stdint.h>\n\n";
872
873   // Emit NEON-specific scalar typedefs.
874   OS << "typedef float float32_t;\n";
875   OS << "typedef int8_t poly8_t;\n";
876   OS << "typedef int16_t poly16_t;\n";
877   OS << "typedef uint16_t float16_t;\n";
878
879   // Emit Neon vector typedefs.
880   std::string TypedefTypes("cQcsQsiQilQlUcQUcUsQUsUiQUiUlQUlhQhfQfPcQPcPsQPs");
881   SmallVector<StringRef, 24> TDTypeVec;
882   ParseTypes(0, TypedefTypes, TDTypeVec);
883
884   // Emit vector typedefs.
885   for (unsigned i = 0, e = TDTypeVec.size(); i != e; ++i) {
886     bool dummy, quad = false, poly = false;
887     (void) ClassifyType(TDTypeVec[i], quad, poly, dummy);
888     if (poly)
889       OS << "typedef __attribute__((neon_polyvector_type(";
890     else
891       OS << "typedef __attribute__((neon_vector_type(";
892       
893     unsigned nElts = GetNumElements(TDTypeVec[i], quad);
894     OS << utostr(nElts) << "))) ";
895     if (nElts < 10)
896       OS << " ";
897       
898     OS << TypeString('s', TDTypeVec[i]);
899     OS << " " << TypeString('d', TDTypeVec[i]) << ";\n";
900   }
901   OS << "\n";
902   OS << "typedef __attribute__((__vector_size__(8)))  "
903     "double float64x1_t;\n";
904   OS << "typedef __attribute__((__vector_size__(16))) "
905     "double float64x2_t;\n";
906   OS << "\n";
907
908   // Emit struct typedefs.
909   for (unsigned vi = 2; vi != 5; ++vi) {
910     for (unsigned i = 0, e = TDTypeVec.size(); i != e; ++i) {
911       std::string ts = TypeString('d', TDTypeVec[i]);
912       std::string vs = TypeString('0' + vi, TDTypeVec[i]);
913       OS << "typedef struct " << vs << " {\n";
914       OS << "  " << ts << " val";
915       OS << "[" << utostr(vi) << "]";
916       OS << ";\n} ";
917       OS << vs << ";\n\n";
918     }
919   }
920   
921   OS << "#define __ai static __attribute__((__always_inline__))\n\n";
922
923   std::vector<Record*> RV = Records.getAllDerivedDefinitions("Inst");
924   
925   // Unique the return+pattern types, and assign them.
926   for (unsigned i = 0, e = RV.size(); i != e; ++i) {
927     Record *R = RV[i];
928     std::string name = LowercaseString(R->getName());
929     std::string Proto = R->getValueAsString("Prototype");
930     std::string Types = R->getValueAsString("Types");
931     
932     SmallVector<StringRef, 16> TypeVec;
933     ParseTypes(R, Types, TypeVec);
934     
935     OpKind k = OpMap[R->getValueAsDef("Operand")->getName()];
936     
937     bool define = Proto.find('i') != std::string::npos;
938     
939     for (unsigned ti = 0, te = TypeVec.size(); ti != te; ++ti) {
940       assert(!Proto.empty() && "");
941       
942       // static always inline + return type
943       if (define)
944         OS << "#define";
945       else
946         OS << "__ai " << TypeString(Proto[0], TypeVec[ti]);
947       
948       // Function name with type suffix
949       OS << " " << MangleName(name, TypeVec[ti], ClassS);
950       
951       // Function arguments
952       OS << GenArgs(Proto, TypeVec[ti]);
953       
954       // Definition.
955       if (define)
956         OS << " ";
957       else
958         OS << " { ";
959       
960       if (k != OpNone) {
961         OS << GenOpString(k, Proto, TypeVec[ti]);
962       } else {
963         if (R->getSuperClasses().size() < 2)
964           throw TGError(R->getLoc(), "Builtin has no class kind");
965         
966         ClassKind ck = ClassMap[R->getSuperClasses()[1]];
967
968         if (ck == ClassNone)
969           throw TGError(R->getLoc(), "Builtin has no class kind");
970         OS << GenBuiltin(name, Proto, TypeVec[ti], ck);
971       }
972       if (!define)
973         OS << " }";
974       OS << "\n";
975     }
976     OS << "\n";
977   }
978   OS << "#undef __ai\n\n";
979   OS << "#endif /* __ARM_NEON_H */\n";
980 }
981
982 static unsigned RangeFromType(StringRef typestr) {
983   // base type to get the type string for.
984   bool quad = false, dummy = false;
985   char type = ClassifyType(typestr, quad, dummy, dummy);
986   
987   switch (type) {
988     case 'c':
989       return (8 << (int)quad) - 1;
990     case 'h':
991     case 's':
992       return (4 << (int)quad) - 1;
993     case 'f':
994     case 'i':
995       return (2 << (int)quad) - 1;
996     case 'l':
997       return (1 << (int)quad) - 1;
998     default:
999       throw "unhandled type!";
1000       break;
1001   }
1002   assert(0 && "unreachable");
1003   return 0;
1004 }
1005
1006 /// runHeader - Emit a file with sections defining:
1007 /// 1. the NEON section of BuiltinsARM.def.
1008 /// 2. the SemaChecking code for the type overload checking.
1009 /// 3. the SemaChecking code for validation of intrinsic immedate arguments.
1010 void NeonEmitter::runHeader(raw_ostream &OS) {
1011   std::vector<Record*> RV = Records.getAllDerivedDefinitions("Inst");
1012
1013   StringMap<OpKind> EmittedMap;
1014   
1015   // Generate BuiltinsARM.def for NEON
1016   OS << "#ifdef GET_NEON_BUILTINS\n";
1017   for (unsigned i = 0, e = RV.size(); i != e; ++i) {
1018     Record *R = RV[i];
1019     OpKind k = OpMap[R->getValueAsDef("Operand")->getName()];
1020     if (k != OpNone)
1021       continue;
1022
1023     std::string Proto = R->getValueAsString("Prototype");
1024     
1025     // Functions with 'a' (the splat code) in the type prototype should not get
1026     // their own builtin as they use the non-splat variant.
1027     if (Proto.find('a') != std::string::npos)
1028       continue;
1029     
1030     std::string Types = R->getValueAsString("Types");
1031     SmallVector<StringRef, 16> TypeVec;
1032     ParseTypes(R, Types, TypeVec);
1033     
1034     if (R->getSuperClasses().size() < 2)
1035       throw TGError(R->getLoc(), "Builtin has no class kind");
1036     
1037     std::string name = LowercaseString(R->getName());
1038     ClassKind ck = ClassMap[R->getSuperClasses()[1]];
1039     
1040     for (unsigned ti = 0, te = TypeVec.size(); ti != te; ++ti) {
1041       // Generate the BuiltinsARM.def declaration for this builtin, ensuring
1042       // that each unique BUILTIN() macro appears only once in the output
1043       // stream.
1044       std::string bd = GenBuiltinDef(name, Proto, TypeVec[ti], ck);
1045       if (EmittedMap.count(bd))
1046         continue;
1047       
1048       EmittedMap[bd] = OpNone;
1049       OS << bd << "\n";
1050     }
1051   }
1052   OS << "#endif\n\n";
1053   
1054   // Generate the overloaded type checking code for SemaChecking.cpp
1055   OS << "#ifdef GET_NEON_OVERLOAD_CHECK\n";
1056   for (unsigned i = 0, e = RV.size(); i != e; ++i) {
1057     Record *R = RV[i];
1058     OpKind k = OpMap[R->getValueAsDef("Operand")->getName()];
1059     if (k != OpNone)
1060       continue;
1061     
1062     std::string Proto = R->getValueAsString("Prototype");
1063     std::string Types = R->getValueAsString("Types");
1064     std::string name = LowercaseString(R->getName());
1065     
1066     // Functions with 'a' (the splat code) in the type prototype should not get
1067     // their own builtin as they use the non-splat variant.
1068     if (Proto.find('a') != std::string::npos)
1069       continue;
1070     
1071     // Functions which have a scalar argument cannot be overloaded, no need to
1072     // check them if we are emitting the type checking code.
1073     if (Proto.find('s') != std::string::npos)
1074       continue;
1075     
1076     SmallVector<StringRef, 16> TypeVec;
1077     ParseTypes(R, Types, TypeVec);
1078     
1079     if (R->getSuperClasses().size() < 2)
1080       throw TGError(R->getLoc(), "Builtin has no class kind");
1081     
1082     int si = -1, qi = -1;
1083     unsigned mask = 0, qmask = 0;
1084     for (unsigned ti = 0, te = TypeVec.size(); ti != te; ++ti) {
1085       // Generate the switch case(s) for this builtin for the type validation.
1086       bool quad = false, poly = false, usgn = false;
1087       (void) ClassifyType(TypeVec[ti], quad, poly, usgn);
1088       
1089       if (quad) {
1090         qi = ti;
1091         qmask |= 1 << GetNeonEnum(Proto, TypeVec[ti]);
1092       } else {
1093         si = ti;
1094         mask |= 1 << GetNeonEnum(Proto, TypeVec[ti]);
1095       }
1096     }
1097     if (mask)
1098       OS << "case ARM::BI__builtin_neon_" 
1099       << MangleName(name, TypeVec[si], ClassB)
1100       << ": mask = " << "0x" << utohexstr(mask) << "; break;\n";
1101     if (qmask)
1102       OS << "case ARM::BI__builtin_neon_" 
1103       << MangleName(name, TypeVec[qi], ClassB)
1104       << ": mask = " << "0x" << utohexstr(qmask) << "; break;\n";
1105   }
1106   OS << "#endif\n\n";
1107   
1108   // Generate the intrinsic range checking code for shift/lane immediates.
1109   OS << "#ifdef GET_NEON_IMMEDIATE_CHECK\n";
1110   for (unsigned i = 0, e = RV.size(); i != e; ++i) {
1111     Record *R = RV[i];
1112     
1113     OpKind k = OpMap[R->getValueAsDef("Operand")->getName()];
1114     if (k != OpNone)
1115       continue;
1116     
1117     std::string name = LowercaseString(R->getName());
1118     std::string Proto = R->getValueAsString("Prototype");
1119     std::string Types = R->getValueAsString("Types");
1120     
1121     // Functions with 'a' (the splat code) in the type prototype should not get
1122     // their own builtin as they use the non-splat variant.
1123     if (Proto.find('a') != std::string::npos)
1124       continue;
1125     
1126     // Functions which do not have an immediate do not need to have range
1127     // checking code emitted.
1128     if (Proto.find('i') == std::string::npos)
1129       continue;
1130     
1131     SmallVector<StringRef, 16> TypeVec;
1132     ParseTypes(R, Types, TypeVec);
1133     
1134     if (R->getSuperClasses().size() < 2)
1135       throw TGError(R->getLoc(), "Builtin has no class kind");
1136     
1137     ClassKind ck = ClassMap[R->getSuperClasses()[1]];
1138     
1139     for (unsigned ti = 0, te = TypeVec.size(); ti != te; ++ti) {
1140       std::string namestr, shiftstr, rangestr;
1141       
1142       // Builtins which are overloaded by type will need to have their upper
1143       // bound computed at Sema time based on the type constant.
1144       if (Proto.find('s') == std::string::npos) {
1145         ck = ClassB;
1146         if (R->getValueAsBit("isShift")) {
1147           shiftstr = ", true";
1148           
1149           // Right shifts have an 'r' in the name, left shifts do not.
1150           if (name.find('r') != std::string::npos)
1151             rangestr = "l = 1; ";
1152         }
1153         rangestr += "u = RFT(TV" + shiftstr + ")";
1154       } else {
1155         rangestr = "u = " + utostr(RangeFromType(TypeVec[ti]));
1156       }
1157       // Make sure cases appear only once by uniquing them in a string map.
1158       namestr = MangleName(name, TypeVec[ti], ck);
1159       if (EmittedMap.count(namestr))
1160         continue;
1161       EmittedMap[namestr] = OpNone;
1162
1163       // Calculate the index of the immediate that should be range checked.
1164       unsigned immidx = 0;
1165       
1166       // Builtins that return a struct of multiple vectors have an extra
1167       // leading arg for the struct return.
1168       if (Proto[0] >= '2' && Proto[0] <= '4')
1169         ++immidx;
1170       
1171       // Add one to the index for each argument until we reach the immediate 
1172       // to be checked.  Structs of vectors are passed as multiple arguments.
1173       for (unsigned ii = 1, ie = Proto.size(); ii != ie; ++ii) {
1174         switch (Proto[ii]) {
1175           default:  immidx += 1; break;
1176           case '2': immidx += 2; break;
1177           case '3': immidx += 3; break;
1178           case '4': immidx += 4; break;
1179           case 'i': ie = ii + 1; break;
1180         }
1181       }
1182       OS << "case ARM::BI__builtin_neon_"  << MangleName(name, TypeVec[ti], ck)
1183          << ": i = " << immidx << "; " << rangestr << "; break;\n";
1184     }
1185   }
1186   OS << "#endif\n\n";
1187 }