Lines Matching +full:kind +full:- +full:of +full:- +full:intr
1 //===- NeonEmitter.cpp - Generate arm_neon.h for use with clang -*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
10 // a declaration and definition of each function specified by the ARM NEON
13 // Each NEON instruction is implemented in terms of 1 or more functions which
14 // are suffixed with the element type of the input vectors. Functions may be
15 // implemented in terms of generic vector operations such as +, *, -, etc. or
16 // by calling a __builtin_-prefixed function which will be handled by clang's
24 //===----------------------------------------------------------------------===//
64 PrintFatalError(CurrentRecord->getLoc(), Str); in assert_with_loc()
74 ClassW, // width-specific instruction, e.g., "8" suffix
83 /// NeonTypeFlags - Flags to identify the types for overloaded Neon
109 //===----------------------------------------------------------------------===//
111 //===----------------------------------------------------------------------===//
135 //===----------------------------------------------------------------------===//
137 //===----------------------------------------------------------------------===//
152 TypeKind Kind; member in __anonfaf0748f0111::Type
162 : Kind(Void), Immediate(false), Constant(false), in Type()
167 : TS(std::move(TS)), Kind(Void), Immediate(false), in Type()
190 bool isFloating() const { return Kind == Float; } in isFloating()
191 bool isInteger() const { return Kind == SInt || Kind == UInt; } in isInteger()
192 bool isPoly() const { return Kind == Poly; } in isPoly()
193 bool isSigned() const { return Kind == SInt; } in isSigned()
202 bool isVoid() const { return Kind == Void; } in isVoid()
203 bool isBFloat16() const { return Kind == BFloat16; } in isBFloat16()
214 Kind = UInt; in makeUnsigned()
218 Kind = SInt; in makeSigned()
223 Kind = Sign ? SInt : UInt; in makeInteger()
229 Kind = SInt; in makeImmediate()
259 /// Return the C string representation of a type, which is the typename
263 /// Return the string representation of a type, which is an encoded
284 //===----------------------------------------------------------------------===//
286 //===----------------------------------------------------------------------===//
301 //===----------------------------------------------------------------------===//
303 //===----------------------------------------------------------------------===//
305 /// The main grunt class. This represents an instantiation of an intrinsic with
313 /// CartesianProductWith is non-empty - this is the case for vreinterpret.
315 /// The base class kind. Most intrinsics use ClassS, which has full type
320 /// The list of DAGs for the body. May be empty, in which case we should
330 /// Is this intrinsic safe for big-endian? or does it need its arguments
334 /// The types of return value [0] and parameters [1..].
336 /// The index of the key type passed to CGBuiltin.cpp for polymorphic calls.
340 /// NeededEarly - set if any other intrinsic depends on this intrinsic.
342 /// UseMacro - set if we should implement using a macro or unset for a
345 /// The set of intrinsics that this intrinsic uses/requires.
348 /// different if CartesianProductWith is non-empty (for vreinterpret).
378 // Modify the TypeSpec per-argument to get a concrete Type, and create in Intrinsic()
387 PolymorphicKeyType = Types.size() - 1; in Intrinsic()
410 /// Get the set of Intrinsics that this intrinsic calls.
411 /// this is the set of immediate dependencies, NOT the
417 /// Get the non-mangled name.
425 /// Return the parameter index of the immediate operand.
429 return Idx - 1; in getImmediateIdx()
434 unsigned getNumParams() const { return Types.size() - 1; } in getNumParams()
445 /// but may not be as things such as multiple-vector operands
459 bool hasBody() const { return Body && !Body->getValues().empty(); } in hasBody()
464 // Sort lexicographically on a three-tuple (ArchGuard, TargetGuard, Name) in operator <()
480 /// of the intrinsic's own type class.
518 Intrinsic &Intr; member in __anonfaf0748f0111::Intrinsic::DagEmitter
522 DagEmitter(Intrinsic &Intr, StringRef CallPrefix) : in DagEmitter() argument
523 Intr(Intr), CallPrefix(CallPrefix) { in DagEmitter()
541 //===----------------------------------------------------------------------===//
543 //===----------------------------------------------------------------------===//
561 /// Called by Intrinsic - this attempts to get an intrinsic that takes
566 /// Called by Intrinsic - returns a globally-unique number.
607 //===----------------------------------------------------------------------===//
609 //===----------------------------------------------------------------------===//
713 --Addend; in getNeonEnum()
718 Base = (unsigned)NeonTypeFlags::Float16 + (Addend - 1); in getNeonEnum()
736 T.Kind = SInt; in fromTypedefName()
739 T.Kind = UInt; in fromTypedefName()
742 T.Kind = Float; in fromTypedefName()
744 T.Kind = Poly; in fromTypedefName()
746 T.Kind = BFloat16; in fromTypedefName()
794 Kind = SInt; in applyTypespec()
811 Kind = Poly; in applyTypespec()
814 Kind = UInt; in applyTypespec()
820 Kind = Float; in applyTypespec()
826 Kind = Float; in applyTypespec()
832 Kind = Float; in applyTypespec()
844 Kind = BFloat16; in applyTypespec()
865 Kind = Void; in applyModifiers()
868 Kind = SInt; in applyModifiers()
871 Kind = UInt; in applyModifiers()
874 Kind = BFloat16; in applyModifiers()
878 Kind = Float; in applyModifiers()
881 Kind = Poly; in applyModifiers()
916 Kind = SInt; in applyModifiers()
923 Kind = UInt; in applyModifiers()
934 //===----------------------------------------------------------------------===//
936 //===----------------------------------------------------------------------===//
1001 // Since the return value must be one type, return a vector type of the in getBuiltinTypeStr()
1003 // returning structs of 2, 3, or 4 vectors which are returned in a sret-like in getBuiltinTypeStr()
1014 // Cast to vector of 8-bit elements. in getBuiltinTypeStr()
1027 // Halves always get converted to 8-bit elements. in getBuiltinTypeStr()
1048 // Check if the prototype has a scalar operand with the type of the vector in getMangledName()
1049 // elements. If not, bitcasting the args will take care of arg checking. in getMangledName()
1050 // The actual signedness etc. will be taken care of with special enums. in getMangledName()
1070 Name[Name.length() - 2] == 'x' && Name[Name.length() - 3] == '_') in mangleName()
1071 S.insert(S.length() - 3, "_" + typeCode); in mangleName()
1077 // A reinterpret - out the input base type at the end. in mangleName()
1085 // _lane or _n on vector-scalar operations. in mangleName()
1116 std::string VarName = S.substr(Pos + 1, End - Pos - 1); in replaceParamsIn()
1119 S.replace(Pos, End - Pos, Variables.find(VarName)->second.getName()); in replaceParamsIn()
1128 // Modify the TypeSpec per-argument to get a concrete Type, and create in initVariables()
1131 char NameC = '0' + (I - 1); in initVariables()
1201 for (int J = Dest.getType().getNumElements() - 1; J >= 0; --J) in emitReverseVariable()
1209 for (int J = Dest.getType().getNumElements() - 1; J >= 0; --J) in emitReverseVariable()
1256 // Macro arguments are not type-checked like inline function arguments, in emitShadowedArgs()
1263 // That would defeat the whole point of using a macro! in emitShadowedArgs()
1296 // sret-like argument. in emitBodyAsBuiltinCall()
1316 // Handle multiple-vector values specially, emitting each subvector as an in emitBodyAsBuiltinCall()
1371 if (!Body || Body->getValues().empty()) { in emitBody()
1372 // Nothing specific to output - must output a builtin. in emitBody()
1377 // We have a list of "things to output". The last should be returned. in emitBody()
1378 for (auto *I : Body->getValues()) { in emitBody()
1380 Lines.push_back(replaceParamsIn(SI->getAsString())); in emitBody()
1409 DefInit *DefI = cast<DefInit>(DI->getOperator()); in emitDag()
1410 std::string Op = DefI->getAsString(); in emitDag()
1437 std::string Op = cast<StringInit>(DI->getArg(0))->getAsUnquotedString(); in emitDagOp()
1438 if (DI->getNumArgs() == 2) { in emitDagOp()
1441 emitDagArg(DI->getArg(1), std::string(DI->getArgNameStr(1))); in emitDagOp()
1444 assert(DI->getNumArgs() == 3 && "Can only handle unary and binary ops!"); in emitDagOp()
1446 emitDagArg(DI->getArg(1), std::string(DI->getArgNameStr(1))); in emitDagOp()
1448 emitDagArg(DI->getArg(2), std::string(DI->getArgNameStr(2))); in emitDagOp()
1458 for (unsigned I = 0; I < DI->getNumArgs() - 1; ++I) { in emitDagCall()
1460 emitDagArg(DI->getArg(I + 1), std::string(DI->getArgNameStr(I + 1))); in emitDagCall()
1467 if (StringInit *SI = dyn_cast<StringInit>(DI->getArg(0))) in emitDagCall()
1468 N = SI->getAsUnquotedString(); in emitDagCall()
1470 N = emitDagArg(DI->getArg(0), "").second; in emitDagCall()
1473 if (Intr.getRecord()->getValueAsBit("isLaneQ")) in emitDagCall()
1475 MangledName = Intr.mangleName(N, ClassS); in emitDagCall()
1477 Intrinsic &Callee = Intr.Emitter.getIntrinsic(N, Types, MangledName); in emitDagCall()
1481 Intr.Dependencies.insert(&Callee); in emitDagCall()
1488 for (unsigned I = 0; I < DI->getNumArgs() - 1; ++I) { in emitDagCall()
1500 // (cast MOD* VAL) -> cast VAL to type given by MOD. in emitDagCast()
1502 emitDagArg(DI->getArg(DI->getNumArgs() - 1), in emitDagCast()
1503 std::string(DI->getArgNameStr(DI->getNumArgs() - 1))); in emitDagCast()
1505 for (unsigned ArgIdx = 0; ArgIdx < DI->getNumArgs() - 1; ++ArgIdx) { in emitDagCast()
1508 // 1. $X - take the type of parameter / variable X. in emitDagCast()
1509 // 2. The value "R" - take the type of the return type. in emitDagCast()
1513 // 6. The value "8" to convert to 8-bit (signed) integer lanes. in emitDagCast()
1514 if (!DI->getArgNameStr(ArgIdx).empty()) { in emitDagCast()
1515 assert_with_loc(Intr.Variables.find(std::string( in emitDagCast()
1516 DI->getArgNameStr(ArgIdx))) != Intr.Variables.end(), in emitDagCast()
1519 Intr.Variables[std::string(DI->getArgNameStr(ArgIdx))].getType(); in emitDagCast()
1521 StringInit *SI = dyn_cast<StringInit>(DI->getArg(ArgIdx)); in emitDagCast()
1524 if (SI->getAsUnquotedString() == "R") { in emitDagCast()
1525 castToType = Intr.getReturnType(); in emitDagCast()
1526 } else if (SI->getAsUnquotedString() == "U") { in emitDagCast()
1528 } else if (SI->getAsUnquotedString() == "S") { in emitDagCast()
1530 } else if (SI->getAsUnquotedString() == "H") { in emitDagCast()
1532 } else if (SI->getAsUnquotedString() == "D") { in emitDagCast()
1534 } else if (SI->getAsUnquotedString() == "8") { in emitDagCast()
1536 } else if (SI->getAsUnquotedString() == "32") { in emitDagCast()
1539 castToType = Type::fromTypedefName(SI->getAsUnquotedString()); in emitDagCast()
1551 while (Intr.Variables.find(N) != Intr.Variables.end()) in emitDagCast()
1553 Intr.Variables[N] = Variable(R.first, N + Intr.VariablePostfix); in emitDagCast()
1555 Intr.OS << R.first.str() << " " << Intr.Variables[N].getName() << " = " in emitDagCast()
1557 Intr.emitNewLine(); in emitDagCast()
1559 S = "*(" + castToType.str() + " *) &" + Intr.Variables[N].getName() + ""; in emitDagCast()
1569 // See the documentation in arm_neon.td for a description of these operators. in emitDagShuffle()
1575 ST.evaluate(Expr->arg_begin(), Expr->arg_end(), Elts2, Loc); in emitDagShuffle()
1585 ST.evaluate(Expr->arg_begin(), Expr->arg_end(), Elts2, Loc); in emitDagShuffle()
1599 ST.evaluate(Expr->arg_begin() + 1, Expr->arg_end(), Elts2, Loc); in emitDagShuffle()
1601 int64_t VectorSize = cast<IntInit>(Expr->getArg(0))->getValue(); in emitDagShuffle()
1606 for (int LI = VectorSize - 1; LI >= 0; --LI) { in emitDagShuffle()
1623 if (R->getName() == "mask0") in emitDagShuffle()
1625 else if (R->getName() == "mask1") in emitDagShuffle()
1630 Elts.insert(R->getRecords().getDef("sv" + utostr(I + Addend))); in emitDagShuffle()
1636 emitDagArg(DI->getArg(0), std::string(DI->getArgNameStr(0))); in emitDagShuffle()
1638 emitDagArg(DI->getArg(1), std::string(DI->getArgNameStr(1))); in emitDagShuffle()
1650 ST.evaluate(DI->getArg(2), Elts, std::nullopt); in emitDagShuffle()
1654 StringRef Name = E->getName(); in emitDagShuffle()
1656 "Incorrect element kind in shuffle mask!"); in emitDagShuffle()
1661 // Recalculate the return type - the shuffle may have halved or doubled it. in emitDagShuffle()
1666 "Can only double or half the number of elements in a shuffle!"); in emitDagShuffle()
1671 "Can only double or half the number of elements in a shuffle!"); in emitDagShuffle()
1679 assert_with_loc(DI->getNumArgs() == 1, "dup() expects one argument"); in emitDagDup()
1681 emitDagArg(DI->getArg(0), std::string(DI->getArgNameStr(0))); in emitDagDup()
1684 Type T = Intr.getBaseType(); in emitDagDup()
1698 assert_with_loc(DI->getNumArgs() == 2, "dup_typed() expects two arguments"); in emitDagDupTyped()
1700 emitDagArg(DI->getArg(1), std::string(DI->getArgNameStr(1))); in emitDagDupTyped()
1705 if (StringInit *SI = dyn_cast<StringInit>(DI->getArg(0))) { in emitDagDupTyped()
1706 T = Type::fromTypedefName(SI->getAsUnquotedString()); in emitDagDupTyped()
1709 T = emitDagArg(DI->getArg(0), std::string(DI->getArgNameStr(0))).first; in emitDagDupTyped()
1724 assert_with_loc(DI->getNumArgs() == 2, "splat() expects two arguments"); in emitDagSplat()
1726 emitDagArg(DI->getArg(0), std::string(DI->getArgNameStr(0))); in emitDagSplat()
1728 emitDagArg(DI->getArg(1), std::string(DI->getArgNameStr(1))); in emitDagSplat()
1734 for (unsigned I = 0; I < Intr.getBaseType().getNumElements(); ++I) { in emitDagSplat()
1739 return std::make_pair(Intr.getBaseType(), S); in emitDagSplat()
1743 assert_with_loc(DI->getNumArgs() == 2, "save_temp() expects two arguments"); in emitDagSaveTemp()
1745 emitDagArg(DI->getArg(1), std::string(DI->getArgNameStr(1))); in emitDagSaveTemp()
1748 "Argument to save_temp() must have non-void type!"); in emitDagSaveTemp()
1750 std::string N = std::string(DI->getArgNameStr(0)); in emitDagSaveTemp()
1754 assert_with_loc(Intr.Variables.find(N) == Intr.Variables.end(), in emitDagSaveTemp()
1756 Intr.Variables[N] = Variable(A.first, N + Intr.VariablePostfix); in emitDagSaveTemp()
1759 A.first.str() + " " + Intr.Variables[N].getName() + " = " + A.second; in emitDagSaveTemp()
1766 std::string S = Intr.Name; in emitDagNameReplace()
1768 assert_with_loc(DI->getNumArgs() == 2, "name_replace requires 2 arguments!"); in emitDagNameReplace()
1769 std::string ToReplace = cast<StringInit>(DI->getArg(0))->getAsUnquotedString(); in emitDagNameReplace()
1770 std::string ReplaceWith = cast<StringInit>(DI->getArg(1))->getAsUnquotedString(); in emitDagNameReplace()
1781 std::string Ty = cast<StringInit>(DI->getArg(0))->getAsUnquotedString(); in emitDagLiteral()
1782 std::string Value = cast<StringInit>(DI->getArg(1))->getAsUnquotedString(); in emitDagLiteral()
1789 assert_with_loc(!Arg->isComplete(), in emitDagArg()
1791 assert_with_loc(Intr.Variables.find(ArgName) != Intr.Variables.end(), in emitDagArg()
1793 Variable &V = Intr.Variables[ArgName]; in emitDagArg()
1819 // intrinsics to operate on a vector "as-if" loaded by (V)LDR, in generate()
1820 // but we load as-if (V)LD1. So we should swap all arguments and in generate()
1823 // If we call sub-intrinsics, we should call a version that does in generate()
1824 // not re-swap the arguments! in generate()
1827 // If we're needed early, create a non-swapping variant for in generate()
1828 // big-endian. in generate()
1842 // lack of proper lexical scoping. So, add a globally unique postfix in generateImpl()
1847 if (I->UseMacro) { in generateImpl()
1861 // -Wdeclaration-after-statement. in generateImpl()
1882 // -Wdeclaration-after-statement. in indexBody()
1890 //===----------------------------------------------------------------------===//
1892 //===----------------------------------------------------------------------===//
1899 auto &V = IntrinsicMap.find(Name.str())->second; in getIntrinsic()
1915 ErrMsg += " - " + I.getReturnType().str() + " " + I.getMangledName(); in getIntrinsic()
1940 "No compatible intrinsic found - " + ErrMsg); in getIntrinsic()
1941 assert_with_loc(GoodVec.size() == 1, "Multiple overloads found - " + ErrMsg); in getIntrinsic()
1948 std::string Name = std::string(R->getValueAsString("Name")); in createIntrinsic()
1949 std::string Proto = std::string(R->getValueAsString("Prototype")); in createIntrinsic()
1950 std::string Types = std::string(R->getValueAsString("Types")); in createIntrinsic()
1951 Record *OperationRec = R->getValueAsDef("Operation"); in createIntrinsic()
1952 bool BigEndianSafe = R->getValueAsBit("BigEndianSafe"); in createIntrinsic()
1953 std::string ArchGuard = std::string(R->getValueAsString("ArchGuard")); in createIntrinsic()
1954 std::string TargetGuard = std::string(R->getValueAsString("TargetGuard")); in createIntrinsic()
1955 bool IsUnavailable = OperationRec->getValueAsBit("Unavailable"); in createIntrinsic()
1956 std::string CartesianProductWith = std::string(R->getValueAsString("CartesianProductWith")); in createIntrinsic()
1962 ListInit *Body = OperationRec->getValueAsListInit("Ops"); in createIntrinsic()
1967 if (R->getSuperClasses().size() >= 2) in createIntrinsic()
1968 CK = ClassMap[R->getSuperClasses()[1].first]; in createIntrinsic()
2004 /// declaration of builtins, checking for unique builtin declarations.
2014 if (Def->hasBody()) in genBuiltinsDef()
2017 std::string S = "__builtin_neon_" + Def->getMangledName() + ", \""; in genBuiltinsDef()
2018 S += Def->getBuiltinTypeStr(); in genBuiltinsDef()
2021 Builtins.emplace(S, Def->getTargetGuard()); in genBuiltinsDef()
2047 if (Def->hasBody()) in genStreamingSVECompatibleList()
2050 std::string Name = Def->getMangledName(); in genStreamingSVECompatibleList()
2070 // definitions may extend the number of permitted types (i.e. augment the in genOverloadTypeCheckCode()
2083 if (Def->hasBody()) in genOverloadTypeCheckCode()
2087 if (Def->protoHasScalar()) in genOverloadTypeCheckCode()
2091 Mask |= 1ULL << Def->getPolymorphicKeyType().getNeonEnum(); in genOverloadTypeCheckCode()
2094 int PtrArgNum = -1; in genOverloadTypeCheckCode()
2096 for (unsigned I = 0; I < Def->getNumParams(); ++I) { in genOverloadTypeCheckCode()
2097 const auto &Type = Def->getParamType(I); in genOverloadTypeCheckCode()
2105 if (PtrArgNum >= 0 && Def->getReturnType().getNumVectors() > 1) in genOverloadTypeCheckCode()
2108 std::string Name = Def->getName(); in genOverloadTypeCheckCode()
2109 // Omit type checking for the pointer arguments of vld1_lane, vld1_dup, in genOverloadTypeCheckCode()
2111 // the vector element type with one of those operations causes codegen to in genOverloadTypeCheckCode()
2117 PtrArgNum = -1; in genOverloadTypeCheckCode()
2122 std::string Name = Def->getMangledName(); in genOverloadTypeCheckCode()
2152 if (Def->hasBody()) in genIntrinsicRangeCheckCode()
2156 if (!Def->hasImmediate()) in genIntrinsicRangeCheckCode()
2158 if (Emitted.find(Def->getMangledName()) != Emitted.end()) in genIntrinsicRangeCheckCode()
2163 Record *R = Def->getRecord(); in genIntrinsicRangeCheckCode()
2164 if (R->getValueAsBit("isVXAR")) { in genIntrinsicRangeCheckCode()
2168 } else if (R->getValueAsBit("isVCVT_N")) { in genIntrinsicRangeCheckCode()
2169 // VCVT between floating- and fixed-point values takes an immediate in genIntrinsicRangeCheckCode()
2172 if (Def->getBaseType().getElementSizeInBits() == 16 || in genIntrinsicRangeCheckCode()
2173 Def->getName().find('h') != std::string::npos) in genIntrinsicRangeCheckCode()
2176 else if (Def->getBaseType().getElementSizeInBits() == 32) in genIntrinsicRangeCheckCode()
2180 } else if (R->getValueAsBit("isScalarShift")) { in genIntrinsicRangeCheckCode()
2183 if (Def->getName().find('r') != std::string::npos || in genIntrinsicRangeCheckCode()
2184 Def->getName().find("cvt") != std::string::npos) in genIntrinsicRangeCheckCode()
2187 UpperBound = utostr(Def->getReturnType().getElementSizeInBits() - 1); in genIntrinsicRangeCheckCode()
2188 } else if (R->getValueAsBit("isShift")) { in genIntrinsicRangeCheckCode()
2193 if (Def->getName().find('r') != std::string::npos) in genIntrinsicRangeCheckCode()
2196 } else if (Def->getClassKind(true) == ClassB) { in genIntrinsicRangeCheckCode()
2199 if (R->getValueAsBit("isLaneQ")) in genIntrinsicRangeCheckCode()
2205 assert(Def->getImmediateIdx() > 0); in genIntrinsicRangeCheckCode()
2206 Type T = Def->getParamType(Def->getImmediateIdx() - 1); in genIntrinsicRangeCheckCode()
2207 UpperBound = utostr(T.getNumElements() - 1); in genIntrinsicRangeCheckCode()
2210 // Calculate the index of the immediate that should be range checked. in genIntrinsicRangeCheckCode()
2211 unsigned Idx = Def->getNumParams(); in genIntrinsicRangeCheckCode()
2212 if (Def->hasImmediate()) in genIntrinsicRangeCheckCode()
2213 Idx = Def->getGeneratedParamIdx(Def->getImmediateIdx()); in genIntrinsicRangeCheckCode()
2215 OS << "case NEON::BI__builtin_neon_" << Def->getMangledName() << ": " in genIntrinsicRangeCheckCode()
2223 Emitted.insert(Def->getMangledName()); in genIntrinsicRangeCheckCode()
2229 /// runHeader - Emit a file with sections defining:
2230 /// 1. the NEON section of BuiltinsARM.def and BuiltinsAArch64.def.
2232 /// 3. the SemaChecking code for validation of intrinsic immediate arguments.
2306 const char Mods[] = { static_cast<char>('2' + (NumMembers - 2)), 0}; in emitNeonTypeDefs()
2320 /// run - Read the records in arm_neon.td and output arm_neon.h. arm_neon.h
2321 /// is comprised of type definitions and function declarations.
2323 OS << "/*===---- arm_neon.h - ARM Neon intrinsics " in run()
2324 "------------------------------" in run()
2325 "---===\n" in run()
2327 " * Permission is hereby granted, free of charge, to any person " in run()
2330 " * of this software and associated documentation files (the " in run()
2338 " * copies of the Software, and to permit persons to whom the Software " in run()
2344 " * all copies or substantial portions of the Software.\n" in run()
2346 " * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, " in run()
2348 " * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF " in run()
2354 " * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, " in run()
2356 " * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER " in run()
2360 " *===-----------------------------------------------------------------" in run()
2361 "---" in run()
2362 "---===\n" in run()
2369 OS << "#error \"NEON intrinsics not available with the soft-float ABI. " in run()
2370 "Please use -mfloat-abi=softfp or -mfloat-abi=hard\"\n"; in run()
2379 // For now, signedness of polynomial types depends on target in run()
2401 I->indexBody(); in run()
2415 for (auto *II : (*I)->getDependencies()) { in run()
2426 if ((*I)->getArchGuard() != InGuard) { in run()
2429 InGuard = (*I)->getArchGuard(); in run()
2435 OS << (*I)->generate(); in run()
2451 /// run - Read the records in arm_fp16.td and output arm_fp16.h. arm_fp16.h
2452 /// is comprised of type definitions and function declarations.
2454 OS << "/*===---- arm_fp16.h - ARM FP16 intrinsics " in runFP16()
2455 "------------------------------" in runFP16()
2456 "---===\n" in runFP16()
2458 " * Permission is hereby granted, free of charge, to any person " in runFP16()
2460 " * of this software and associated documentation files (the " in runFP16()
2466 " * copies of the Software, and to permit persons to whom the Software " in runFP16()
2472 " * all copies or substantial portions of the Software.\n" in runFP16()
2474 " * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, " in runFP16()
2476 " * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF " in runFP16()
2482 " * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, " in runFP16()
2484 " * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER " in runFP16()
2488 " *===-----------------------------------------------------------------" in runFP16()
2489 "---" in runFP16()
2490 "---===\n" in runFP16()
2509 I->indexBody(); in runFP16()
2523 for (auto *II : (*I)->getDependencies()) { in runFP16()
2534 if ((*I)->getArchGuard() != InGuard) { in runFP16()
2537 InGuard = (*I)->getArchGuard(); in runFP16()
2543 OS << (*I)->generate(); in runFP16()
2559 OS << "/*===---- arm_vector_types - ARM vector type " in runVectorTypes()
2560 "------===\n" in runVectorTypes()
2563 " * Part of the LLVM Project, under the Apache License v2.0 with LLVM " in runVectorTypes()
2566 " * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\n" in runVectorTypes()
2568 " *===-----------------------------------------------------------------" in runVectorTypes()
2569 "------===\n" in runVectorTypes()
2591 OS << "/*===---- arm_bf16.h - ARM BF16 intrinsics " in runBF16()
2592 "-----------------------------------===\n" in runBF16()
2595 " * Part of the LLVM Project, under the Apache License v2.0 with LLVM " in runBF16()
2598 " * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\n" in runBF16()
2600 " *===-----------------------------------------------------------------" in runBF16()
2601 "------===\n" in runBF16()
2618 I->indexBody(); in runBF16()
2632 for (auto *II : (*I)->getDependencies()) { in runBF16()
2643 if ((*I)->getArchGuard() != InGuard) { in runBF16()
2646 InGuard = (*I)->getArchGuard(); in runBF16()
2652 OS << (*I)->generate(); in runBF16()