// a declaration and definition of each function specified by the ARM NEON
// compiler interface. See ARM document DUI0348B.
//
+// Each NEON instruction is implemented in terms of 1 or more functions which
+// are suffixed with the element type of the input vectors. Functions may be
+// implemented in terms of generic vector operations such as +, *, -, etc. or
+// by calling a __builtin_-prefixed function which will be handled by clang's
+// CodeGen library.
+//
+// Additional validation code can be generated by this file when runHeader() is
+// called, rather than the normal run() entry point.
+//
//===----------------------------------------------------------------------===//
#include "NeonEmitter.h"
using namespace llvm;
+/// ParseTypes - break down a string such as "fQf" into a vector of StringRefs,
+/// which each StringRef representing a single type declared in the string.
+/// for "fQf" we would end up with 2 StringRefs, "f", and "Qf", representing
+/// 2xfloat and 4xfloat respectively.
static void ParseTypes(Record *r, std::string &s,
SmallVectorImpl<StringRef> &TV) {
const char *data = s.data();
}
}
+/// Widen - Convert a type code into the next wider type. char -> short,
+/// short -> int, etc.
static char Widen(const char t) {
switch (t) {
case 'c':
return '\0';
}
+/// Narrow - Convert a type code into the next smaller type. short -> char,
+/// float -> half float, etc.
static char Narrow(const char t) {
switch (t) {
case 's':
return '\0';
}
+/// For a particular StringRef, return the base type code, and whether it has
+/// the quad-vector, polynomial, or unsigned modifiers set.
static char ClassifyType(StringRef ty, bool &quad, bool &poly, bool &usgn) {
unsigned off = 0;
return ty[off];
}
+/// ModType - Transform a type code and its modifiers based on a mod code. The
+/// mod code definitions may be found at the top of arm_neon.td.
static char ModType(const char mod, char type, bool &quad, bool &poly,
bool &usgn, bool &scal, bool &cnst, bool &pntr) {
switch (mod) {
return type;
}
+/// TypeString - for a modifier and type, generate the name of the typedef for
+/// that type. If generic is true, emit the generic vector type rather than
+/// the public NEON type. QUc -> uint8x8t_t / __neon_uint8x8_t.
static std::string TypeString(const char mod, StringRef typestr,
- bool ret = false) {
+ bool generic = false) {
bool quad = false;
bool poly = false;
bool usgn = false;
SmallString<128> s;
- if (ret)
+ if (generic)
s += "__neon_";
if (usgn)
return s.str();
}
+/// TypeString - for a modifier and type, generate the clang BuiltinsARM.def
+/// prototype code for the function. See the top of clang's Builtins.def for
+/// a description of the type strings.
static std::string BuiltinTypeString(const char mod, StringRef typestr,
ClassKind ck, bool ret) {
bool quad = false;
return quad ? "V16c" : "V8c";
}
-// Turn "vst2_lane" into "vst2q_lane_f32", etc.
+/// MangleName - Append a type or width suffix to a base neon function name,
+/// and insert a 'q' in the appropriate location if the operation works on
+/// 128b rather than 64b. E.g. turn "vst2_lane" into "vst2q_lane_f32", etc.
static std::string MangleName(const std::string &name, StringRef typestr,
ClassKind ck) {
if (name == "vcvt_f32_f16")
ret |= 0x08;
if (quad)
ret |= 0x10;
- if (poly)
- ret |= 0x20;
switch (type) {
case 'c':
return s;
}
+/// run - Read the records in arm_neon.td and output arm_neon.h. arm_neon.h
+/// is comprised of type definitions and function declarations.
void NeonEmitter::run(raw_ostream &OS) {
EmitSourceFileHeader("ARM NEON Header", OS);
OS << "#include <stdint.h>\n\n";
// Emit NEON-specific scalar typedefs.
- // FIXME: probably need to do something better for polynomial types.
OS << "typedef float float32_t;\n";
OS << "typedef uint8_t poly8_t;\n";
OS << "typedef uint16_t poly16_t;\n";
OS << "#endif /* __ARM_NEON_H */\n";
}
+/// runHeader - generate one of three different tables which are used by clang
+/// to support ARM NEON codegen. By default, this will produce the contents of
+/// BuiltinsARM.def's NEON section. You may also enable the genSemaTypes or
+/// getSemaRange variables below to generate code that SemaChecking will use to
+/// validate the builtin function calls.
+///
+/// This is not used as part of the build system currently, but is run manually
+/// and the output placed in the appropriate file.
void NeonEmitter::runHeader(raw_ostream &OS) {
std::vector<Record*> RV = Records.getAllDerivedDefinitions("Inst");
StringMap<OpKind> EmittedMap;
+ // Set true to generate the overloaded type checking code for SemaChecking.cpp
+ bool genSemaTypes = false;
+
+ // Set true to generate the intrinsic range checking code for shift/lane
+ // immediates for SemaChecking.cpp
+ bool genSemaRange = true;
+
for (unsigned i = 0, e = RV.size(); i != e; ++i) {
Record *R = RV[i];
std::string Proto = R->getValueAsString("Prototype");
std::string Types = R->getValueAsString("Types");
+ // Functions with 'a' (the splat code) in the type prototype should not get
+ // their own builtin as they use the non-splat variant.
if (Proto.find('a') != std::string::npos)
continue;
-
+
+ // Functions which have a scalar argument cannot be overloaded, no need to
+ // check them if we are emitting the type checking code.
+ if (genSemaTypes && Proto.find('s') != std::string::npos)
+ continue;
+
+ // Functions which do not have an immediate do not need to have range
+ // checking code emitted.
+ if (genSemaRange && Proto.find('i') == std::string::npos)
+ continue;
+
SmallVector<StringRef, 16> TypeVec;
ParseTypes(R, Types, TypeVec);
-
+
if (R->getSuperClasses().size() < 2)
throw TGError(R->getLoc(), "Builtin has no class kind");
ClassKind ck = ClassMap[R->getSuperClasses()[1]];
+ int si = -1, qi = -1;
+ unsigned mask = 0, qmask = 0;
for (unsigned ti = 0, te = TypeVec.size(); ti != te; ++ti) {
+
+ // Generate the switch case(s) for this builtin for the type validation.
+ if (genSemaTypes) {
+ bool quad = false, poly = false, usgn = false;
+ (void) ClassifyType(TypeVec[ti], quad, poly, usgn);
+
+ if (quad) {
+ qi = ti;
+ qmask |= 1 << GetNeonEnum(Proto, TypeVec[ti]);
+ } else {
+ si = ti;
+ mask |= 1 << GetNeonEnum(Proto, TypeVec[ti]);
+ }
+ continue;
+ }
+
+ if (genSemaRange) {
+ if (Proto.find('s') == std::string::npos)
+ ck = ClassB;
+
+ OS << "case ARM::BI__builtin_neon_"
+ << MangleName(name, TypeVec[ti], ck) << "\n";
+ continue;
+ }
+
+ // Generate the BuiltinsARM.def declaration for this builtin, ensuring
+ // that each unique BUILTIN() macro appears only once in the output
+ // stream.
std::string bd = GenBuiltinDef(name, Proto, TypeVec[ti], ck);
if (EmittedMap.count(bd))
continue;
EmittedMap[bd] = OpNone;
OS << bd << "\n";
}
+
+ if (genSemaTypes) {
+ if (mask)
+ OS << "case ARM::BI__builtin_neon_"
+ << MangleName(name, TypeVec[si], ClassB)
+ << ": mask = " << "0x" << utohexstr(mask) << "; break;\n";
+ if (qmask)
+ OS << "case ARM::BI__builtin_neon_"
+ << MangleName(name, TypeVec[qi], ClassB)
+ << ": mask = " << "0x" << utohexstr(qmask) << "; break;\n";
+ continue;
+ }
}
}
projects / oota-llvm.git / commitdiff