diff options
368 files changed, 27961 insertions, 29272 deletions
diff --git a/.github/new-prs-labeler.yml b/.github/new-prs-labeler.yml index c49fd1d..efdc42d 100644 --- a/.github/new-prs-labeler.yml +++ b/.github/new-prs-labeler.yml @@ -1096,8 +1096,8 @@ clang:openmp: - llvm/test/Transforms/OpenMP/** clang:temporal-safety: - - clang/include/clang/Analysis/Analyses/LifetimeSafety* - - clang/lib/Analysis/LifetimeSafety* + - clang/include/clang/Analysis/Analyses/LifetimeSafety/** + - clang/lib/Analysis/LifetimeSafety/** - clang/unittests/Analysis/LifetimeSafety* - clang/test/Sema/*lifetime-safety* - clang/test/Sema/*lifetime-analysis* diff --git a/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp b/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp index ed595e1..2545548 100644 --- a/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp +++ b/clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.cpp @@ -108,7 +108,7 @@ void InitVariablesCheck::check(const MatchFinder::MatchResult &Result) { << MatchedDecl; if (*InitializationString != nullptr) Diagnostic << FixItHint::CreateInsertion( - utils::lexer::findNextTerminator(MatchedDecl->getLocation(), + utils::lexer::findNextTerminator(MatchedDecl->getEndLoc(), *Result.SourceManager, Result.Context->getLangOpts()), *InitializationString); diff --git a/clang-tools-extra/clangd/Hover.cpp b/clang-tools-extra/clangd/Hover.cpp index 138544d..acc8e87 100644 --- a/clang-tools-extra/clangd/Hover.cpp +++ b/clang-tools-extra/clangd/Hover.cpp @@ -1537,6 +1537,12 @@ markup::Document HoverInfo::presentDoxygen() const { SymbolDocCommentVisitor SymbolDoc(Documentation, CommentOpts); if (SymbolDoc.hasBriefCommand()) { + if (Kind != index::SymbolKind::Parameter && + Kind != index::SymbolKind::TemplateTypeParm) + // Only add a "Brief" heading if we are not documenting a parameter. + // Parameters only have a brief section and adding the brief header would + // be redundant. + Output.addHeading(3).appendText("Brief"); SymbolDoc.briefToMarkup(Output.addParagraph()); Output.addRuler(); } @@ -1550,7 +1556,7 @@ markup::Document HoverInfo::presentDoxygen() const { // Returns // `type` - description if (TemplateParameters && !TemplateParameters->empty()) { - Output.addParagraph().appendBoldText("Template Parameters:"); + Output.addHeading(3).appendText("Template Parameters"); markup::BulletList &L = Output.addBulletList(); for (const auto &Param : *TemplateParameters) { markup::Paragraph &P = L.addItem().addParagraph(); @@ -1564,7 +1570,7 @@ markup::Document HoverInfo::presentDoxygen() const { } if (Parameters && !Parameters->empty()) { - Output.addParagraph().appendBoldText("Parameters:"); + Output.addHeading(3).appendText("Parameters"); markup::BulletList &L = Output.addBulletList(); for (const auto &Param : *Parameters) { markup::Paragraph &P = L.addItem().addParagraph(); @@ -1583,7 +1589,7 @@ markup::Document HoverInfo::presentDoxygen() const { if (ReturnType && ((ReturnType->Type != "void" && !ReturnType->AKA.has_value()) || (ReturnType->AKA.has_value() && ReturnType->AKA != "void"))) { - Output.addParagraph().appendBoldText("Returns:"); + Output.addHeading(3).appendText("Returns"); markup::Paragraph &P = Output.addParagraph(); P.appendCode(llvm::to_string(*ReturnType)); @@ -1591,15 +1597,15 @@ markup::Document HoverInfo::presentDoxygen() const { P.appendText(" - "); SymbolDoc.returnToMarkup(P); } + + SymbolDoc.retvalsToMarkup(Output); Output.addRuler(); } - // add specially handled doxygen commands. - SymbolDoc.warningsToMarkup(Output); - SymbolDoc.notesToMarkup(Output); - - // add any other documentation. - SymbolDoc.docToMarkup(Output); + if (SymbolDoc.hasDetailedDoc()) { + Output.addHeading(3).appendText("Details"); + SymbolDoc.detailedDocToMarkup(Output); + } Output.addRuler(); diff --git a/clang-tools-extra/clangd/SymbolDocumentation.cpp b/clang-tools-extra/clangd/SymbolDocumentation.cpp index 9ae1ef3..a50d7a5 100644 --- a/clang-tools-extra/clangd/SymbolDocumentation.cpp +++ b/clang-tools-extra/clangd/SymbolDocumentation.cpp @@ -13,6 +13,7 @@ #include "clang/AST/CommentCommandTraits.h" #include "clang/AST/CommentVisitor.h" #include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" namespace clang { @@ -34,10 +35,20 @@ void commandToMarkup(markup::Paragraph &Out, StringRef Command, StringRef Args) { Out.appendBoldText(commandMarkerAsString(CommandMarker) + Command.str()); Out.appendSpace(); - if (!Args.empty()) { - Out.appendEmphasizedText(Args.str()); + if (!Args.empty()) + Out.appendCode(Args.str()); +} + +template <typename T> std::string getArgText(const T *Command) { + std::string ArgText; + for (unsigned I = 0; I < Command->getNumArgs(); ++I) { + if (!ArgText.empty()) + ArgText += " "; + ArgText += Command->getArgText(I); } + return ArgText; } + } // namespace class ParagraphToMarkupDocument @@ -70,12 +81,7 @@ public: void visitInlineCommandComment(const comments::InlineCommandComment *C) { if (C->getNumArgs() > 0) { - std::string ArgText; - for (unsigned I = 0; I < C->getNumArgs(); ++I) { - if (!ArgText.empty()) - ArgText += " "; - ArgText += C->getArgText(I); - } + std::string ArgText = getArgText(C); switch (C->getRenderKind()) { case comments::InlineCommandRenderKind::Monospaced: @@ -158,10 +164,9 @@ public: void visitInlineCommandComment(const comments::InlineCommandComment *C) { Out << commandMarkerAsString(C->getCommandMarker()); Out << C->getCommandName(Traits); - if (C->getNumArgs() > 0) { - for (unsigned I = 0; I < C->getNumArgs(); ++I) - Out << " " << C->getArgText(I); - } + std::string ArgText = getArgText(C); + if (!ArgText.empty()) + Out << " " << ArgText; Out << " "; } @@ -210,16 +215,38 @@ public: Traits) .visit(B->getParagraph()); break; + case comments::CommandTraits::KCI_note: + case comments::CommandTraits::KCI_warning: + commandToHeadedParagraph(B); + break; + case comments::CommandTraits::KCI_retval: { + // The \retval command describes the return value given as its single + // argument in the corresponding paragraph. + // Note: We know that we have exactly one argument but not if it has an + // associated paragraph. + auto &P = Out.addParagraph().appendCode(getArgText(B)); + if (B->getParagraph() && !B->getParagraph()->isWhitespace()) { + P.appendText(" - "); + ParagraphToMarkupDocument(P, Traits).visit(B->getParagraph()); + } + return; + } + case comments::CommandTraits::KCI_details: { + // The \details command is just used to separate the brief from the + // detailed description. This separation is already done in the + // SymbolDocCommentVisitor. Therefore we can omit the command itself + // here and just process the paragraph. + if (B->getParagraph() && !B->getParagraph()->isWhitespace()) { + ParagraphToMarkupDocument(Out.addParagraph(), Traits) + .visit(B->getParagraph()); + } + return; + } default: { // Some commands have arguments, like \throws. // The arguments are not part of the paragraph. // We need reconstruct them here. - std::string ArgText; - for (unsigned I = 0; I < B->getNumArgs(); ++I) { - if (!ArgText.empty()) - ArgText += " "; - ArgText += B->getArgText(I); - } + std::string ArgText = getArgText(B); auto &P = Out.addParagraph(); commandToMarkup(P, B->getCommandName(Traits), B->getCommandMarker(), ArgText); @@ -234,7 +261,53 @@ public: } } + void visitCodeCommand(const comments::VerbatimBlockComment *VB) { + std::string CodeLang = ""; + auto *FirstLine = VB->child_begin(); + // The \\code command has an optional language argument. + // This argument is currently not parsed by the clang doxygen parser. + // Therefore we try to extract it from the first line of the verbatim + // block. + if (VB->getNumLines() > 0) { + if (const auto *Line = + cast<comments::VerbatimBlockLineComment>(*FirstLine)) { + llvm::StringRef Text = Line->getText(); + // Language is a single word enclosed in {}. + if (llvm::none_of(Text, llvm::isSpace) && Text.consume_front("{") && + Text.consume_back("}")) { + // drop a potential . since this is not supported in Markdown + // fenced code blocks. + Text.consume_front("."); + // Language is alphanumeric or '+'. + CodeLang = Text.take_while([](char C) { + return llvm::isAlnum(C) || C == '+'; + }) + .str(); + // Skip the first line for the verbatim text. + ++FirstLine; + } + } + } + + std::string CodeBlockText; + + for (const auto *LI = FirstLine; LI != VB->child_end(); ++LI) { + if (const auto *Line = cast<comments::VerbatimBlockLineComment>(*LI)) { + CodeBlockText += Line->getText().str() + "\n"; + } + } + + Out.addCodeBlock(CodeBlockText, CodeLang); + } + void visitVerbatimBlockComment(const comments::VerbatimBlockComment *VB) { + // The \\code command is a special verbatim block command which we handle + // separately. + if (VB->getCommandID() == comments::CommandTraits::KCI_code) { + visitCodeCommand(VB); + return; + } + commandToMarkup(Out.addParagraph(), VB->getCommandName(Traits), VB->getCommandMarker(), ""); @@ -262,8 +335,123 @@ private: markup::Document &Out; const comments::CommandTraits &Traits; StringRef CommentEscapeMarker; + + /// Emphasize the given command in a paragraph. + /// Uses the command name with the first letter capitalized as the heading. + void commandToHeadedParagraph(const comments::BlockCommandComment *B) { + auto &P = Out.addParagraph(); + std::string Heading = B->getCommandName(Traits).slice(0, 1).upper() + + B->getCommandName(Traits).drop_front().str(); + P.appendBoldText(Heading + ":"); + P.appendText(" \n"); + ParagraphToMarkupDocument(P, Traits).visit(B->getParagraph()); + } }; +void SymbolDocCommentVisitor::preprocessDocumentation(StringRef Doc) { + enum State { + Normal, + FencedCodeblock, + } State = Normal; + std::string CodeFence; + + llvm::raw_string_ostream OS(CommentWithMarkers); + + // The documentation string is processed line by line. + // The raw documentation string does not contain the comment markers + // (e.g. /// or /** */). + // But the comment lexer expects doxygen markers, so add them back. + // We need to use the /// style doxygen markers because the comment could + // contain the closing tag "*/" of a C Style "/** */" comment + // which would break the parsing if we would just enclose the comment text + // with "/** */". + + // Escape doxygen commands inside markdown inline code spans. + // This is required to not let the doxygen parser interpret them as + // commands. + // Note: This is a heuristic which may fail in some cases. + bool InCodeSpan = false; + + llvm::StringRef Line, Rest; + for (std::tie(Line, Rest) = Doc.split('\n'); !(Line.empty() && Rest.empty()); + std::tie(Line, Rest) = Rest.split('\n')) { + + // Detect code fence (``` or ~~~) + if (State == Normal) { + llvm::StringRef Trimmed = Line.ltrim(); + if (Trimmed.starts_with("```") || Trimmed.starts_with("~~~")) { + // https://www.doxygen.nl/manual/markdown.html#md_fenced + CodeFence = + Trimmed.take_while([](char C) { return C == '`' || C == '~'; }) + .str(); + // Try to detect language: first word after fence. Could also be + // enclosed in {} + llvm::StringRef AfterFence = + Trimmed.drop_front(CodeFence.size()).ltrim(); + // ignore '{' at the beginning of the language name to not duplicate it + // for the doxygen command + AfterFence.consume_front("{"); + // The name is alphanumeric or '.' or '+' + StringRef CodeLang = AfterFence.take_while( + [](char C) { return llvm::isAlnum(C) || C == '.' || C == '+'; }); + + OS << "///@code"; + + if (!CodeLang.empty()) + OS << "{" << CodeLang.str() << "}"; + + OS << "\n"; + + State = FencedCodeblock; + continue; + } + + // FIXME: handle indented code blocks too? + // In doxygen, the indentation which triggers a code block depends on the + // indentation of the previous paragraph. + // https://www.doxygen.nl/manual/markdown.html#mddox_code_blocks + } else if (State == FencedCodeblock) { + // End of code fence + if (Line.ltrim().starts_with(CodeFence)) { + OS << "///@endcode\n"; + State = Normal; + continue; + } + OS << "///" << Line << "\n"; + continue; + } + + // Normal line preprocessing (add doxygen markers, handle escaping) + OS << "///"; + + if (Line.empty() || Line.trim().empty()) { + OS << "\n"; + // Empty lines reset the InCodeSpan state. + InCodeSpan = false; + continue; + } + + if (Line.starts_with("<")) + // A comment line starting with '///<' is treated as a doxygen + // command. To avoid this, we add a space before the '<'. + OS << ' '; + + for (char C : Line) { + if (C == '`') + InCodeSpan = !InCodeSpan; + else if (InCodeSpan && (C == '@' || C == '\\')) + OS << '\\'; + OS << C; + } + + OS << "\n"; + } + + // Close any unclosed code block + if (State == FencedCodeblock) + OS << "///@endcode\n"; +} + void SymbolDocCommentVisitor::visitBlockCommandComment( const comments::BlockCommandComment *B) { switch (B->getCommandID()) { @@ -282,36 +470,22 @@ void SymbolDocCommentVisitor::visitBlockCommandComment( } break; case comments::CommandTraits::KCI_retval: - RetvalParagraphs.push_back(B->getParagraph()); - return; - case comments::CommandTraits::KCI_warning: - WarningParagraphs.push_back(B->getParagraph()); - return; - case comments::CommandTraits::KCI_note: - NoteParagraphs.push_back(B->getParagraph()); + // Only consider retval commands having an argument. + // The argument contains the described return value which is needed to + // convert it to markup. + if (B->getNumArgs() == 1) + RetvalCommands.push_back(B); return; default: break; } - // For all other commands, we store them in the UnhandledCommands map. + // For all other commands, we store them in the BlockCommands map. // This allows us to keep the order of the comments. - UnhandledCommands[CommentPartIndex] = B; + BlockCommands[CommentPartIndex] = B; CommentPartIndex++; } -void SymbolDocCommentVisitor::paragraphsToMarkup( - markup::Document &Out, - const llvm::SmallVectorImpl<const comments::ParagraphComment *> &Paragraphs) - const { - if (Paragraphs.empty()) - return; - - for (const auto *P : Paragraphs) { - ParagraphToMarkupDocument(Out.addParagraph(), Traits).visit(P); - } -} - void SymbolDocCommentVisitor::briefToMarkup(markup::Paragraph &Out) const { if (!BriefParagraph) return; @@ -324,14 +498,6 @@ void SymbolDocCommentVisitor::returnToMarkup(markup::Paragraph &Out) const { ParagraphToMarkupDocument(Out, Traits).visit(ReturnParagraph); } -void SymbolDocCommentVisitor::notesToMarkup(markup::Document &Out) const { - paragraphsToMarkup(Out, NoteParagraphs); -} - -void SymbolDocCommentVisitor::warningsToMarkup(markup::Document &Out) const { - paragraphsToMarkup(Out, WarningParagraphs); -} - void SymbolDocCommentVisitor::parameterDocToMarkup( StringRef ParamName, markup::Paragraph &Out) const { if (ParamName.empty()) @@ -352,9 +518,9 @@ void SymbolDocCommentVisitor::parameterDocToString( } } -void SymbolDocCommentVisitor::docToMarkup(markup::Document &Out) const { +void SymbolDocCommentVisitor::detailedDocToMarkup(markup::Document &Out) const { for (unsigned I = 0; I < CommentPartIndex; ++I) { - if (const auto *BC = UnhandledCommands.lookup(I)) { + if (const auto *BC = BlockCommands.lookup(I)) { BlockCommentToMarkupDocument(Out, Traits).visit(BC); } else if (const auto *P = FreeParagraphs.lookup(I)) { ParagraphToMarkupDocument(Out.addParagraph(), Traits).visit(P); @@ -382,5 +548,14 @@ void SymbolDocCommentVisitor::templateTypeParmDocToString( } } +void SymbolDocCommentVisitor::retvalsToMarkup(markup::Document &Out) const { + if (RetvalCommands.empty()) + return; + markup::BulletList &BL = Out.addBulletList(); + for (const auto *P : RetvalCommands) { + BlockCommentToMarkupDocument(BL.addItem(), Traits).visit(P); + } +} + } // namespace clangd } // namespace clang diff --git a/clang-tools-extra/clangd/SymbolDocumentation.h b/clang-tools-extra/clangd/SymbolDocumentation.h index b0d3428..88c7ade 100644 --- a/clang-tools-extra/clangd/SymbolDocumentation.h +++ b/clang-tools-extra/clangd/SymbolDocumentation.h @@ -21,6 +21,7 @@ #include "clang/AST/CommentSema.h" #include "clang/AST/CommentVisitor.h" #include "clang/Basic/SourceManager.h" +#include "llvm/ADT/StringRef.h" #include "llvm/Support/raw_ostream.h" #include <string> @@ -51,31 +52,8 @@ public: CommentWithMarkers.reserve(Documentation.size() + Documentation.count('\n') * 3); - // The comment lexer expects doxygen markers, so add them back. - // We need to use the /// style doxygen markers because the comment could - // contain the closing the closing tag "*/" of a C Style "/** */" comment - // which would break the parsing if we would just enclose the comment text - // with "/** */". - CommentWithMarkers = "///"; - bool NewLine = true; - for (char C : Documentation) { - if (C == '\n') { - CommentWithMarkers += "\n///"; - NewLine = true; - } else { - if (NewLine && (C == '<')) { - // A comment line starting with '///<' is treated as a doxygen - // comment. Therefore add a space to separate the '<' from the comment - // marker. This allows to parse html tags at the beginning of a line - // and the escape marker prevents adding the artificial space in the - // markup documentation. The extra space will not be rendered, since - // we render it as markdown. - CommentWithMarkers += ' '; - } - CommentWithMarkers += C; - NewLine = false; - } - } + preprocessDocumentation(Documentation); + SourceManagerForFile SourceMgrForFile("mock_file.cpp", CommentWithMarkers); SourceManager &SourceMgr = SourceMgrForFile.get(); @@ -100,6 +78,14 @@ public: for (auto *Block : FC->getBlocks()) { visit(Block); } + + // If we have not seen a brief command, use the very first free paragraph as + // the brief. + if (!BriefParagraph && !FreeParagraphs.empty() && + FreeParagraphs.contains(0)) { + BriefParagraph = FreeParagraphs.lookup(0); + FreeParagraphs.erase(0); + } } bool isParameterDocumented(StringRef ParamName) const { @@ -114,22 +100,18 @@ public: bool hasReturnCommand() const { return ReturnParagraph; } - bool hasRetvalCommands() const { return !RetvalParagraphs.empty(); } - - bool hasNoteCommands() const { return !NoteParagraphs.empty(); } - - bool hasWarningCommands() const { return !WarningParagraphs.empty(); } + bool hasDetailedDoc() const { + return !FreeParagraphs.empty() || !BlockCommands.empty(); + } /// Converts all unhandled comment commands to a markup document. - void docToMarkup(markup::Document &Out) const; + void detailedDocToMarkup(markup::Document &Out) const; /// Converts the "brief" command(s) to a markup document. void briefToMarkup(markup::Paragraph &Out) const; /// Converts the "return" command(s) to a markup document. void returnToMarkup(markup::Paragraph &Out) const; - /// Converts the "note" command(s) to a markup document. - void notesToMarkup(markup::Document &Out) const; - /// Converts the "warning" command(s) to a markup document. - void warningsToMarkup(markup::Document &Out) const; + /// Converts the "retval" command(s) to a markup document. + void retvalsToMarkup(markup::Document &Out) const; void visitBlockCommandComment(const comments::BlockCommandComment *B); @@ -145,8 +127,10 @@ public: llvm::raw_string_ostream &Out) const; void visitParagraphComment(const comments::ParagraphComment *P) { - FreeParagraphs[CommentPartIndex] = P; - CommentPartIndex++; + if (!P->isWhitespace()) { + FreeParagraphs[CommentPartIndex] = P; + CommentPartIndex++; + } } void visitParamCommandComment(const comments::ParamCommandComment *P) { @@ -157,6 +141,27 @@ public: TemplateParameters[TP->getParamNameAsWritten()] = std::move(TP); } + /// \brief Preprocesses the raw documentation string to prepare it for doxygen + /// parsing. + /// + /// This is a workaround to provide better support for markdown in + /// doxygen. Clang's doxygen parser e.g. does not handle markdown code blocks. + /// + /// The documentation string is preprocessed to replace some markdown + /// constructs with parsable doxygen commands. E.g. markdown code blocks are + /// replaced with doxygen \\code{.lang} ... + /// \\endcode blocks. + /// + /// Additionally, potential doxygen commands inside markdown + /// inline code spans are escaped to avoid that doxygen tries to interpret + /// them as commands. + /// + /// \note Although this is a workaround, it is very similar to what + /// doxygen itself does for markdown. In doxygen, the first parsing step is + /// also a markdown preprocessing step. + /// See https://www.doxygen.nl/manual/markdown.html + void preprocessDocumentation(StringRef Doc); + private: comments::CommandTraits Traits; llvm::BumpPtrAllocator Allocator; @@ -173,19 +178,13 @@ private: /// Paragraph of the "return" command. const comments::ParagraphComment *ReturnParagraph = nullptr; - /// Paragraph(s) of the "note" command(s) - llvm::SmallVector<const comments::ParagraphComment *> RetvalParagraphs; + /// All the "retval" command(s) + llvm::SmallVector<const comments::BlockCommandComment *> RetvalCommands; - /// Paragraph(s) of the "note" command(s) - llvm::SmallVector<const comments::ParagraphComment *> NoteParagraphs; - - /// Paragraph(s) of the "warning" command(s) - llvm::SmallVector<const comments::ParagraphComment *> WarningParagraphs; - - /// All the paragraphs we don't have any special handling for, - /// e.g. "details". + /// All the parsed doxygen block commands. + /// They might have special handling internally like \\note or \\warning llvm::SmallDenseMap<unsigned, const comments::BlockCommandComment *> - UnhandledCommands; + BlockCommands; /// Parsed paragaph(s) of the "param" comamnd(s) llvm::SmallDenseMap<StringRef, const comments::ParamCommandComment *> @@ -198,11 +197,6 @@ private: /// All "free" text paragraphs. llvm::SmallDenseMap<unsigned, const comments::ParagraphComment *> FreeParagraphs; - - void paragraphsToMarkup( - markup::Document &Out, - const llvm::SmallVectorImpl<const comments::ParagraphComment *> - &Paragraphs) const; }; } // namespace clangd diff --git a/clang-tools-extra/clangd/support/Markup.cpp b/clang-tools-extra/clangd/support/Markup.cpp index 89bdc65..304917d 100644 --- a/clang-tools-extra/clangd/support/Markup.cpp +++ b/clang-tools-extra/clangd/support/Markup.cpp @@ -199,10 +199,16 @@ bool needsLeadingEscape(char C, llvm::StringRef Before, llvm::StringRef After, return needsLeadingEscapeMarkdown(C, After); } -/// Escape a markdown text block. +/// \brief Render text for markdown output. +/// /// If \p EscapeMarkdown is true it ensures the punctuation will not introduce /// any of the markdown constructs. +/// /// Else, markdown syntax is not escaped, only HTML tags and entities. +/// HTML is escaped because usually clients do not support HTML rendering by +/// default. Passing unescaped HTML will therefore often result in not showing +/// the HTML at all. +/// \note In markdown code spans, we do not escape anything. std::string renderText(llvm::StringRef Input, bool StartsLine, bool EscapeMarkdown) { std::string R; @@ -213,6 +219,10 @@ std::string renderText(llvm::StringRef Input, bool StartsLine, bool IsFirstLine = true; + // Inside markdown code spans, we do not escape anything when EscapeMarkdown + // is false. + bool InCodeSpan = false; + for (std::tie(Line, Rest) = Input.split('\n'); !(Line.empty() && Rest.empty()); std::tie(Line, Rest) = Rest.split('\n')) { @@ -226,12 +236,27 @@ std::string renderText(llvm::StringRef Input, bool StartsLine, R.append(LeadingSpaces); } + // Handle the case where the user escaped a character themselves. + // This is relevant for markdown code spans if EscapeMarkdown is false, + // because if the user escaped a backtick, we must treat the enclosed text + // as normal markdown text. + bool UserEscape = false; for (unsigned I = LeadingSpaces.size(); I < Line.size(); ++I) { - if (needsLeadingEscape(Line[I], Line.substr(LeadingSpaces.size(), I), + + if (!EscapeMarkdown && !UserEscape && Line[I] == '`') + InCodeSpan = !InCodeSpan; + + if (!InCodeSpan && + needsLeadingEscape(Line[I], Line.substr(LeadingSpaces.size(), I), Line.substr(I + 1), StartsLineIntern, EscapeMarkdown)) R.push_back('\\'); R.push_back(Line[I]); + + if (Line[I] == '\\') + UserEscape = !UserEscape; + else + UserEscape = false; } IsFirstLine = false; diff --git a/clang-tools-extra/clangd/unittests/HoverTests.cpp b/clang-tools-extra/clangd/unittests/HoverTests.cpp index e9abf71..718c1bc 100644 --- a/clang-tools-extra/clangd/unittests/HoverTests.cpp +++ b/clang-tools-extra/clangd/unittests/HoverTests.cpp @@ -3457,13 +3457,15 @@ template <typename T, typename C = bool> class Foo {} ``` --- -**Template Parameters:** +### Brief -- `typename T` -- `typename C = bool` +documentation --- -documentation +### Template Parameters + +- `typename T` +- `typename C = bool` --- Size: 10 bytes)", @@ -3506,7 +3508,7 @@ ret_type foo(params) {} ``` --- -**Parameters:** +### Parameters - - `type (aka can_type)` @@ -3514,7 +3516,7 @@ ret_type foo(params) {} - `type foo = default (aka can_type)` --- -**Returns:** +### Returns `ret_type (aka can_ret_type)`)", }, @@ -3649,7 +3651,7 @@ protected: size_t method() ``` --- -**Returns:** +### Returns `size_t (aka unsigned long)`)", }, @@ -3688,7 +3690,7 @@ public: cls(int a, int b = 5) ``` --- -**Parameters:** +### Parameters - `int a` - `int b = 5`)", @@ -4001,9 +4003,13 @@ void foo() ``` --- +### Brief + brief doc --- +### Details + longer doc)"}, {[](HoverInfo &HI) { HI.Kind = index::SymbolKind::Function; @@ -4034,20 +4040,34 @@ int foo() ``` --- +### Brief + brief doc --- -**Returns:** +### Returns `int` --- +### Details + longer doc)"}, {[](HoverInfo &HI) { HI.Kind = index::SymbolKind::Function; - HI.Documentation = "@brief brief doc\n\n" - "longer doc\n@param a this is a param\n@return it " - "returns something"; + HI.Documentation = R"(@brief brief doc + +longer doc +@note this is a note + +As you see, notes are "inlined". +@warning this is a warning + +As well as warnings +@param a this is a param +@return it returns something +@retval 0 if successful +@retval 1 if failed)"; HI.Definition = "int foo(int a)"; HI.ReturnType = "int"; HI.Name = "foo"; @@ -4068,8 +4088,16 @@ Parameters: @brief brief doc longer doc +@note this is a note + +As you see, notes are "inlined". +@warning this is a warning + +As well as warnings @param a this is a param @return it returns something +@retval 0 if successful +@retval 1 if failed --- ```cpp @@ -4083,20 +4111,37 @@ int foo(int a) ``` --- +### Brief + brief doc --- -**Parameters:** +### Parameters - `int a` - this is a param --- -**Returns:** +### Returns `int` - it returns something +- `0` - if successful +- `1` - if failed + --- -longer doc)"}, +### Details + +longer doc + +**Note:** +this is a note + +As you see, notes are "inlined". + +**Warning:** +this is a warning + +As well as warnings)"}, {[](HoverInfo &HI) { HI.Kind = index::SymbolKind::Function; HI.Documentation = "@brief brief doc\n\n" @@ -4138,19 +4183,23 @@ int foo(int a) ``` --- +### Brief + brief doc --- -**Parameters:** +### Parameters - `int a` - this is a param --- -**Returns:** +### Returns `int` - it returns something --- +### Details + longer doc)"}, }; diff --git a/clang-tools-extra/clangd/unittests/SymbolDocumentationTests.cpp b/clang-tools-extra/clangd/unittests/SymbolDocumentationTests.cpp index 31a6a14..b3185cc 100644 --- a/clang-tools-extra/clangd/unittests/SymbolDocumentationTests.cpp +++ b/clang-tools-extra/clangd/unittests/SymbolDocumentationTests.cpp @@ -15,7 +15,7 @@ namespace clang { namespace clangd { -TEST(SymbolDocumentation, UnhandledDocs) { +TEST(SymbolDocumentation, DetailedDocToMarkup) { CommentOptions CommentOpts; @@ -26,52 +26,52 @@ TEST(SymbolDocumentation, UnhandledDocs) { llvm::StringRef ExpectedRenderPlainText; } Cases[] = { { - "foo bar", + "brief\n\nfoo bar", "foo bar", "foo bar", "foo bar", }, { - "foo\nbar\n", + "brief\n\nfoo\nbar\n", "foo\nbar", "foo\nbar", "foo bar", }, { - "foo\n\nbar\n", + "brief\n\nfoo\n\nbar\n", "foo\n\nbar", "foo\n\nbar", "foo\n\nbar", }, { - "foo \\p bar baz", + "brief\n\nfoo \\p bar baz", "foo `bar` baz", "foo `bar` baz", "foo bar baz", }, { - "foo \\e bar baz", + "brief\n\nfoo \\e bar baz", "foo \\*bar\\* baz", "foo *bar* baz", "foo *bar* baz", }, { - "foo \\b bar baz", + "brief\n\nfoo \\b bar baz", "foo \\*\\*bar\\*\\* baz", "foo **bar** baz", "foo **bar** baz", }, { - "foo \\ref bar baz", - "foo \\*\\*\\\\ref\\*\\* \\*bar\\* baz", - "foo **\\ref** *bar* baz", - "foo **\\ref** *bar* baz", + "brief\n\nfoo \\ref bar baz", + "foo \\*\\*\\\\ref\\*\\* `bar` baz", + "foo **\\ref** `bar` baz", + "foo **\\ref** bar baz", }, { - "foo @ref bar baz", - "foo \\*\\*@ref\\*\\* \\*bar\\* baz", - "foo **@ref** *bar* baz", - "foo **@ref** *bar* baz", + "brief\n\nfoo @ref bar baz", + "foo \\*\\*@ref\\*\\* `bar` baz", + "foo **@ref** `bar` baz", + "foo **@ref** bar baz", }, { "\\brief this is a \\n\nbrief description", @@ -80,10 +80,10 @@ TEST(SymbolDocumentation, UnhandledDocs) { "", }, { - "\\throw exception foo", - "\\*\\*\\\\throw\\*\\* \\*exception\\* foo", - "**\\throw** *exception* foo", - "**\\throw** *exception* foo", + "brief\n\n\\throw exception foo", + "\\*\\*\\\\throw\\*\\* `exception` foo", + "**\\throw** `exception` foo", + "**\\throw** exception foo", }, { R"(\brief this is a brief description @@ -108,7 +108,8 @@ TEST(SymbolDocumentation, UnhandledDocs) { - item 3)", }, { - "\\defgroup mygroup this is a group\nthis is not a group description", + "brief\n\n\\defgroup mygroup this is a group\nthis is not a group " + "description", "\\*\\*@defgroup\\*\\* `mygroup this is a group`\n\nthis is not a " "group " "description", @@ -118,7 +119,9 @@ TEST(SymbolDocumentation, UnhandledDocs) { "description", }, { - R"(\verbatim + R"(brief + +\verbatim this is a verbatim block containing some verbatim text @@ -150,7 +153,7 @@ some verbatim text **@endverbatim**)", }, { - "@param foo this is a parameter\n@param bar this is another " + "brief\n\n@param foo this is a parameter\n@param bar this is another " "parameter", "", "", @@ -169,24 +172,26 @@ More description documentation)", R"(\*\*\\brief\*\* another brief? -\*\*\\details\*\* these are details +these are details More description documentation)", R"(**\brief** another brief? -**\details** these are details +these are details More description documentation)", R"(**\brief** another brief? -**\details** these are details +these are details More description documentation)", }, { - R"(<b>this is a bold text</b> + R"(brief + +<b>this is a bold text</b> normal text<i>this is an italic text</i> <code>this is a code block</code>)", R"(\<b>this is a bold text\</b> @@ -198,12 +203,528 @@ normal text\<i>this is an italic text\</i> "<b>this is a bold text</b> normal text<i>this is an italic text</i> " "<code>this is a code block</code>", }, + {"brief\n\n@note This is a note", + R"(\*\*Note:\*\* +This is a note)", + R"(**Note:** +This is a note)", + R"(**Note:** +This is a note)"}, + {R"(brief + +Paragraph 1 +@note This is a note + +Paragraph 2)", + R"(Paragraph 1 + +\*\*Note:\*\* +This is a note + +Paragraph 2)", + R"(Paragraph 1 + +**Note:** +This is a note + +Paragraph 2)", + R"(Paragraph 1 + +**Note:** +This is a note + +Paragraph 2)"}, + {"brief\n\n@warning This is a warning", + R"(\*\*Warning:\*\* +This is a warning)", + R"(**Warning:** +This is a warning)", + R"(**Warning:** +This is a warning)"}, + {R"(brief + +Paragraph 1 +@warning This is a warning + +Paragraph 2)", + R"(Paragraph 1 + +\*\*Warning:\*\* +This is a warning + +Paragraph 2)", + R"(Paragraph 1 + +**Warning:** +This is a warning + +Paragraph 2)", + R"(Paragraph 1 + +**Warning:** +This is a warning + +Paragraph 2)"}, + {R"(@note this is not treated as brief + +@brief this is the brief + +Another paragraph)", + R"(\*\*Note:\*\* +this is not treated as brief + +Another paragraph)", + R"(**Note:** +this is not treated as brief + +Another paragraph)", + R"(**Note:** +this is not treated as brief + +Another paragraph)"}, + {R"( +@brief Some brief +)", + "", "", ""}, + {R"( +Some brief +)", + "", "", ""}, + }; + for (const auto &C : Cases) { + markup::Document Doc; + SymbolDocCommentVisitor SymbolDoc(C.Documentation, CommentOpts); + + SymbolDoc.detailedDocToMarkup(Doc); + + EXPECT_EQ(Doc.asPlainText(), C.ExpectedRenderPlainText); + EXPECT_EQ(Doc.asMarkdown(), C.ExpectedRenderMarkdown); + EXPECT_EQ(Doc.asEscapedMarkdown(), C.ExpectedRenderEscapedMarkdown); + } +} + +TEST(SymbolDocumentation, RetvalCommand) { + + CommentOptions CommentOpts; + + struct Case { + llvm::StringRef Documentation; + llvm::StringRef ExpectedRenderEscapedMarkdown; + llvm::StringRef ExpectedRenderMarkdown; + llvm::StringRef ExpectedRenderPlainText; + } Cases[] = { + {"@retval", "", "", ""}, + {R"(@retval MyReturnVal +@retval MyOtherReturnVal)", + R"(- `MyReturnVal` +- `MyOtherReturnVal`)", + R"(- `MyReturnVal` +- `MyOtherReturnVal`)", + R"(- MyReturnVal +- MyOtherReturnVal)"}, + {R"(@retval MyReturnVal if foo +@retval MyOtherReturnVal if bar)", + R"(- `MyReturnVal` - if foo +- `MyOtherReturnVal` - if bar)", + R"(- `MyReturnVal` - if foo +- `MyOtherReturnVal` - if bar)", + R"(- MyReturnVal - if foo +- MyOtherReturnVal - if bar)"}, + }; + for (const auto &C : Cases) { + markup::Document Doc; + SymbolDocCommentVisitor SymbolDoc(C.Documentation, CommentOpts); + + SymbolDoc.retvalsToMarkup(Doc); + + EXPECT_EQ(Doc.asPlainText(), C.ExpectedRenderPlainText); + EXPECT_EQ(Doc.asMarkdown(), C.ExpectedRenderMarkdown); + EXPECT_EQ(Doc.asEscapedMarkdown(), C.ExpectedRenderEscapedMarkdown); + } +} + +TEST(SymbolDocumentation, DoxygenCodeBlocks) { + CommentOptions CommentOpts; + + struct Case { + llvm::StringRef Documentation; + llvm::StringRef ExpectedRenderEscapedMarkdown; + llvm::StringRef ExpectedRenderMarkdown; + llvm::StringRef ExpectedRenderPlainText; + } Cases[] = { + {R"(@code +int code() { return 0; } +@endcode +@code{.cpp} +int code_lang() { return 0; } +@endcode +@code{.c++} +int code_lang_plus() { return 0; } +@endcode +@code{.py} +class A: + pass +@endcode +@code{nolang} +class B: + pass +@endcode)", + R"(``` +int code() { return 0; } +``` + +```cpp +int code_lang() { return 0; } +``` + +```c++ +int code_lang_plus() { return 0; } +``` + +```py +class A: + pass +``` + +```nolang +class B: + pass +```)", + R"(``` +int code() { return 0; } +``` + +```cpp +int code_lang() { return 0; } +``` + +```c++ +int code_lang_plus() { return 0; } +``` + +```py +class A: + pass +``` + +```nolang +class B: + pass +```)", + R"(int code() { return 0; } + +int code_lang() { return 0; } + +int code_lang_plus() { return 0; } + +class A: + pass + +class B: + pass)"}, + }; + for (const auto &C : Cases) { + markup::Document Doc; + SymbolDocCommentVisitor SymbolDoc(C.Documentation, CommentOpts); + + SymbolDoc.detailedDocToMarkup(Doc); + + EXPECT_EQ(Doc.asPlainText(), C.ExpectedRenderPlainText); + EXPECT_EQ(Doc.asMarkdown(), C.ExpectedRenderMarkdown); + EXPECT_EQ(Doc.asEscapedMarkdown(), C.ExpectedRenderEscapedMarkdown); + } +} + +TEST(SymbolDocumentation, MarkdownCodeBlocks) { + CommentOptions CommentOpts; + + struct Case { + llvm::StringRef Documentation; + llvm::StringRef ExpectedRenderEscapedMarkdown; + llvm::StringRef ExpectedRenderMarkdown; + llvm::StringRef ExpectedRenderPlainText; + } Cases[] = { + {R"(``` +int backticks() { return 0; } +``` +```cpp +int backticks_lang() { return 0; } +``` +```c++ +int backticks_lang_plus() { return 0; } +``` +~~~ +int tilde() { return 0; } +~~~ +~~~~~~~~~~~~~~~~~~~~~~~~ +int tilde_many() { return 0; } +~~~~~~~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~~~~~{.c++} +int tilde_many_lang() { return 0; } +~~~~~~~~~~~~~~~~~~~~~~~~ +```py +class A: + pass +``` +```python +class B: + pass +``` +~~~{.python} +class C: + pass +~~~ +)", + R"(``` +int backticks() { return 0; } +``` + +```cpp +int backticks_lang() { return 0; } +``` + +```c++ +int backticks_lang_plus() { return 0; } +``` + +``` +int tilde() { return 0; } +``` + +``` +int tilde_many() { return 0; } +``` + +```c++ +int tilde_many_lang() { return 0; } +``` + +```py +class A: + pass +``` + +```python +class B: + pass +``` + +```python +class C: + pass +```)", + R"(``` +int backticks() { return 0; } +``` + +```cpp +int backticks_lang() { return 0; } +``` + +```c++ +int backticks_lang_plus() { return 0; } +``` + +``` +int tilde() { return 0; } +``` + +``` +int tilde_many() { return 0; } +``` + +```c++ +int tilde_many_lang() { return 0; } +``` + +```py +class A: + pass +``` + +```python +class B: + pass +``` + +```python +class C: + pass +```)", + R"(int backticks() { return 0; } + +int backticks_lang() { return 0; } + +int backticks_lang_plus() { return 0; } + +int tilde() { return 0; } + +int tilde_many() { return 0; } + +int tilde_many_lang() { return 0; } + +class A: + pass + +class B: + pass + +class C: + pass)"}, + {R"(``` +// this code block is missing end backticks + +)", + R"(``` +// this code block is missing end backticks +```)", + R"(``` +// this code block is missing end backticks +```)", + R"(// this code block is missing end backticks)"}, + }; + for (const auto &C : Cases) { + markup::Document Doc; + SymbolDocCommentVisitor SymbolDoc(C.Documentation, CommentOpts); + + SymbolDoc.detailedDocToMarkup(Doc); + + EXPECT_EQ(Doc.asPlainText(), C.ExpectedRenderPlainText); + EXPECT_EQ(Doc.asMarkdown(), C.ExpectedRenderMarkdown); + EXPECT_EQ(Doc.asEscapedMarkdown(), C.ExpectedRenderEscapedMarkdown); + } +} + +TEST(SymbolDocumentation, MarkdownCodeBlocksSeparation) { + CommentOptions CommentOpts; + + struct Case { + llvm::StringRef Documentation; + llvm::StringRef ExpectedRenderEscapedMarkdown; + llvm::StringRef ExpectedRenderMarkdown; + llvm::StringRef ExpectedRenderPlainText; + } Cases[] = { + {R"(@note Show that code blocks are correctly separated +``` +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; } +```)", + R"(\*\*Note:\*\* +Show that code blocks are correctly separated + +``` +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; } +```)", + R"(**Note:** +Show that code blocks are correctly separated + +``` +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; } +```)", + R"(**Note:** +Show that code blocks are correctly separated + +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; })"}, + {R"(@note Show that code blocks are correctly separated +~~~~~~~~~ +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; } +~~~~~~~~~)", + R"(\*\*Note:\*\* +Show that code blocks are correctly separated + +``` +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; } +```)", + R"(**Note:** +Show that code blocks are correctly separated + +``` +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; } +```)", + R"(**Note:** +Show that code blocks are correctly separated + +/// Without the markdown preprocessing, this line and the line above would be part of the @note paragraph. + +/// With preprocessing, the code block is correctly separated from the @note paragraph. +/// Also note that without preprocessing, all doxygen commands inside code blocks, like @p would be incorrectly interpreted. +int function() { return 0; })"}, + }; + for (const auto &C : Cases) { + markup::Document Doc; + SymbolDocCommentVisitor SymbolDoc(C.Documentation, CommentOpts); + + SymbolDoc.detailedDocToMarkup(Doc); + + EXPECT_EQ(Doc.asPlainText(), C.ExpectedRenderPlainText); + EXPECT_EQ(Doc.asMarkdown(), C.ExpectedRenderMarkdown); + EXPECT_EQ(Doc.asEscapedMarkdown(), C.ExpectedRenderEscapedMarkdown); + } +} + +TEST(SymbolDocumentation, MarkdownCodeSpans) { + CommentOptions CommentOpts; + + struct Case { + llvm::StringRef Documentation; + llvm::StringRef ExpectedRenderEscapedMarkdown; + llvm::StringRef ExpectedRenderMarkdown; + llvm::StringRef ExpectedRenderPlainText; + } Cases[] = { + {R"(`this is a code span with @p and \c inside`)", + R"(\`this is a code span with @p and \\c inside\`)", + R"(`this is a code span with @p and \c inside`)", + R"(`this is a code span with @p and \c inside`)"}, + {R"(<escaped> `<not-escaped>`)", R"(\<escaped> \`\<not-escaped>\`)", + R"(\<escaped> `<not-escaped>`)", R"(<escaped> `<not-escaped>`)"}, + {R"(<escaped> \`<escaped> doxygen commands not parsed @p, \c, @note, \warning \`)", + R"(\<escaped> \\\`\<escaped> doxygen commands not parsed @p, \\c, @note, \\warning \\\`)", + R"(\<escaped> \`\<escaped> doxygen commands not parsed @p, \c, @note, \warning \`)", + R"(<escaped> \`<escaped> doxygen commands not parsed @p, \c, @note, \warning \`)"}, + {R"(`multi +line +\c span`)", + R"(\`multi +line +\\c span\`)", + R"(`multi +line +\c span`)", + R"(`multi line +\c span`)"}, }; for (const auto &C : Cases) { markup::Document Doc; SymbolDocCommentVisitor SymbolDoc(C.Documentation, CommentOpts); - SymbolDoc.docToMarkup(Doc); + SymbolDoc.briefToMarkup(Doc.addParagraph()); EXPECT_EQ(Doc.asPlainText(), C.ExpectedRenderPlainText); EXPECT_EQ(Doc.asMarkdown(), C.ExpectedRenderMarkdown); diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst index d2d79dc..9aeda03 100644 --- a/clang-tools-extra/docs/ReleaseNotes.rst +++ b/clang-tools-extra/docs/ReleaseNotes.rst @@ -307,6 +307,10 @@ Changes in existing checks an additional matcher that generalizes the copy-and-swap idiom pattern detection. +- Improved :doc:`cppcoreguidelines-init-variables + <clang-tidy/checks/cppcoreguidelines/init-variables>` check by fixing the + insertion location for function pointers with multiple parameters. + - Improved :doc:`cppcoreguidelines-prefer-member-initializer <clang-tidy/checks/cppcoreguidelines/prefer-member-initializer>` check to avoid false positives on inherited members in class templates. diff --git a/clang-tools-extra/test/clang-tidy/checkers/abseil/cleanup-ctad.cpp b/clang-tools-extra/test/clang-tidy/checkers/abseil/cleanup-ctad.cpp index c2b5e4d..53400ac 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/abseil/cleanup-ctad.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/abseil/cleanup-ctad.cpp @@ -79,27 +79,27 @@ absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) { void test() { auto a = absl::MakeCleanup([] {}); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup's class template argument deduction pattern in C++17 and higher - // CHECK-FIXES: {{^}} absl::Cleanup a = [] {};{{$}} + // CHECK-FIXES: absl::Cleanup a = [] {}; auto b = absl::MakeCleanup(std::function<void()>([] {})); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher - // CHECK-FIXES: {{^}} absl::Cleanup b = std::function<void()>([] {});{{$}} + // CHECK-FIXES: absl::Cleanup b = std::function<void()>([] {}); const auto c = absl::MakeCleanup([] {}); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: prefer absl::Cleanup{{.*}}C++17 and higher - // CHECK-FIXES: {{^}} const absl::Cleanup c = [] {};{{$}} + // CHECK-FIXES: const absl::Cleanup c = [] {}; const auto d = absl::MakeCleanup(std::function<void()>([] {})); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: prefer absl::Cleanup{{.*}}C++17 and higher - // CHECK-FIXES: {{^}} const absl::Cleanup d = std::function<void()>([] {});{{$}} + // CHECK-FIXES: const absl::Cleanup d = std::function<void()>([] {}); // Preserves extra parens auto e = absl::MakeCleanup(([] {})); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher - // CHECK-FIXES: {{^}} absl::Cleanup e = ([] {});{{$}} + // CHECK-FIXES: absl::Cleanup e = ([] {}); // Preserves comments auto f = /* a */ absl::MakeCleanup(/* b */ [] { /* c */ } /* d */) /* e */; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer absl::Cleanup{{.*}}C++17 and higher - // CHECK-FIXES: {{^}} absl::Cleanup f = /* a */ /* b */ [] { /* c */ } /* d */ /* e */;{{$}} + // CHECK-FIXES: absl::Cleanup f = /* a */ /* b */ [] { /* c */ } /* d */ /* e */; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/abseil/str-cat-append.cpp b/clang-tools-extra/test/clang-tidy/checkers/abseil/str-cat-append.cpp index 9a2585d..90936fb 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/abseil/str-cat-append.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/abseil/str-cat-append.cpp @@ -97,7 +97,7 @@ void Bar() { // CHECK-MESSAGES: [[@LINE-1]]:3: warning: call to 'absl::StrCat' has no effect A = StrCat(A, B); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty -// CHECK-FIXES: {{^}} absl::StrAppend(&A, B); +// CHECK-FIXES: absl::StrAppend(&A, B); B = StrCat(A, B); #define M(X) X = StrCat(X, A) @@ -117,7 +117,7 @@ void OutsideAbsl() { std::string A, B; A = absl::StrCat(A, B); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty -// CHECK-FIXES: {{^}} absl::StrAppend(&A, B); +// CHECK-FIXES: absl::StrAppend(&A, B); } void OutsideUsingAbsl() { @@ -125,5 +125,5 @@ void OutsideUsingAbsl() { using absl::StrCat; A = StrCat(A, B); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: call 'absl::StrAppend' instead of 'absl::StrCat' when appending to a string to avoid a performance penalty -// CHECK-FIXES: {{^}} absl::StrAppend(&A, B); +// CHECK-FIXES: absl::StrAppend(&A, B); } diff --git a/clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp b/clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp index bb9ba99..c5d1f17 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp @@ -70,41 +70,41 @@ void basic_tests() { std::string ss; ss.find("a") == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of find() == npos - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}} + // CHECK-FIXES: !absl::StrContains(ss, "a"); ss.find("a") != std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of find() != npos - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}} + // CHECK-FIXES: absl::StrContains(ss, "a"); std::string::npos != ss.find("a"); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}} + // CHECK-FIXES: absl::StrContains(ss, "a"); std::string_view ssv; ssv.find("a") == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "a");{{$}} + // CHECK-FIXES: !absl::StrContains(ssv, "a"); ssv.find("a") != std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}} + // CHECK-FIXES: absl::StrContains(ssv, "a"); std::string_view::npos != ssv.find("a"); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}} + // CHECK-FIXES: absl::StrContains(ssv, "a"); absl::string_view asv; asv.find("a") == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "a");{{$}} + // CHECK-FIXES: !absl::StrContains(asv, "a"); asv.find("a") != absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}} + // CHECK-FIXES: absl::StrContains(asv, "a"); absl::string_view::npos != asv.find("a"); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}} + // CHECK-FIXES: absl::StrContains(asv, "a"); } // Confirms that it works even if you mix-and-match the type for find and for @@ -115,29 +115,29 @@ void mismatched_npos() { std::string ss; ss.find("a") == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}} + // CHECK-FIXES: !absl::StrContains(ss, "a"); ss.find("a") != absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}} + // CHECK-FIXES: absl::StrContains(ss, "a"); std::string_view ssv; ssv.find("a") == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "a");{{$}} + // CHECK-FIXES: !absl::StrContains(ssv, "a"); ssv.find("a") != std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}} + // CHECK-FIXES: absl::StrContains(ssv, "a"); absl::string_view asv; asv.find("a") == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "a");{{$}} + // CHECK-FIXES: !absl::StrContains(asv, "a"); asv.find("a") != std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}} + // CHECK-FIXES: absl::StrContains(asv, "a"); } // Confirms that it works even when the needle or the haystack are more @@ -146,41 +146,41 @@ void subexpression_tests() { std::string ss, ss2; foo_ss(ss).find(ss2) == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_ss(ss), ss2);{{$}} + // CHECK-FIXES: !absl::StrContains(foo_ss(ss), ss2); ss.find(foo_ss(ss2)) != std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, foo_ss(ss2));{{$}} + // CHECK-FIXES: absl::StrContains(ss, foo_ss(ss2)); foo_ss(bar_ss()).find(foo_ss(ss2)) != std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_ss(bar_ss()), foo_ss(ss2));{{$}} + // CHECK-FIXES: absl::StrContains(foo_ss(bar_ss()), foo_ss(ss2)); std::string_view ssv, ssv2; foo_ssv(ssv).find(ssv2) == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_ssv(ssv), ssv2);{{$}} + // CHECK-FIXES: !absl::StrContains(foo_ssv(ssv), ssv2); ssv.find(foo_ssv(ssv2)) != std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, foo_ssv(ssv2));{{$}} + // CHECK-FIXES: absl::StrContains(ssv, foo_ssv(ssv2)); foo_ssv(bar_ssv()).find(foo_ssv(ssv2)) != std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_ssv(bar_ssv()), foo_ssv(ssv2));{{$}} + // CHECK-FIXES: absl::StrContains(foo_ssv(bar_ssv()), foo_ssv(ssv2)); absl::string_view asv, asv2; foo_asv(asv).find(asv2) == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_asv(asv), asv2);{{$}} + // CHECK-FIXES: !absl::StrContains(foo_asv(asv), asv2); asv.find(foo_asv(asv2)) != absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, foo_asv(asv2));{{$}} + // CHECK-FIXES: absl::StrContains(asv, foo_asv(asv2)); foo_asv(bar_asv()).find(foo_asv(asv2)) != absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_asv(bar_asv()), foo_asv(asv2));{{$}} + // CHECK-FIXES: absl::StrContains(foo_asv(bar_asv()), foo_asv(asv2)); } // Confirms that it works with string literal, char* and const char* parameters. @@ -191,58 +191,58 @@ void string_literal_and_char_ptr_tests() { std::string ss; ss.find("c") == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "c");{{$}} + // CHECK-FIXES: !absl::StrContains(ss, "c"); ss.find(c) == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, c);{{$}} + // CHECK-FIXES: !absl::StrContains(ss, c); ss.find(cc) == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, cc);{{$}} + // CHECK-FIXES: !absl::StrContains(ss, cc); std::string_view ssv; ssv.find("c") == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "c");{{$}} + // CHECK-FIXES: !absl::StrContains(ssv, "c"); ssv.find(c) == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, c);{{$}} + // CHECK-FIXES: !absl::StrContains(ssv, c); ssv.find(cc) == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, cc);{{$}} + // CHECK-FIXES: !absl::StrContains(ssv, cc); absl::string_view asv; asv.find("c") == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "c");{{$}} + // CHECK-FIXES: !absl::StrContains(asv, "c"); asv.find(c) == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, c);{{$}} + // CHECK-FIXES: !absl::StrContains(asv, c); asv.find(cc) == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, cc);{{$}} + // CHECK-FIXES: !absl::StrContains(asv, cc); } void char_param_tests() { std::string ss; ss.find('c') == std::string::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, 'c');{{$}} + // CHECK-FIXES: !absl::StrContains(ss, 'c'); std::string_view ssv; ssv.find('c') == std::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, 'c');{{$}} + // CHECK-FIXES: !absl::StrContains(ssv, 'c'); absl::string_view asv; asv.find('c') == absl::string_view::npos; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of - // CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, 'c');{{$}} + // CHECK-FIXES: !absl::StrContains(asv, 'c'); } #define FOO(a, b, c, d) ((a).find(b) == std::string::npos ? (c) : (d)) diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment.cpp index 3b977ad..28b19cc 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment.cpp @@ -12,7 +12,7 @@ void g() { // CHECK-NOTES: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y' // CHECK-NOTES: [[@LINE-5]]:19: note: 'y' declared here f(/*y=*/0, /*z=*/0); - // CHECK-FIXES: {{^}} f(/*y=*/0, /*z=*/0); + // CHECK-FIXES: f(/*y=*/0, /*z=*/0); f(/*x=*/1, /*y=*/1); diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/inaccurate-erase.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/inaccurate-erase.cpp index d29fa9c..dfb4b9e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/inaccurate-erase.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/inaccurate-erase.cpp @@ -51,12 +51,12 @@ struct custom_container { template <typename T> void g() { T t; t.erase(std::remove(t.begin(), t.end(), 10)); - // CHECK-FIXES: {{^ }}t.erase(std::remove(t.begin(), t.end(), 10));{{$}} + // CHECK-FIXES: t.erase(std::remove(t.begin(), t.end(), 10)); std::vector<int> v; v.erase(remove(v.begin(), v.end(), 10)); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one - // CHECK-FIXES: {{^ }}v.erase(remove(v.begin(), v.end(), 10), v.end());{{$}} + // CHECK-FIXES: v.erase(remove(v.begin(), v.end(), 10), v.end()); } #define ERASE(x, y) x.erase(remove(x.begin(), x.end(), y)) @@ -67,34 +67,34 @@ int main() { v.erase(remove(v.begin(), v.end(), 10)); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one item even when multiple items should be removed [bugprone-inaccurate-erase] - // CHECK-FIXES: {{^ }}v.erase(remove(v.begin(), v.end(), 10), v.end());{{$}} + // CHECK-FIXES: v.erase(remove(v.begin(), v.end(), 10), v.end()); v.erase(remove(v.begin(), v.end(), 20), v.end()); auto *p = &v; p->erase(remove(p->begin(), p->end(), 11)); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one - // CHECK-FIXES: {{^ }}p->erase(remove(p->begin(), p->end(), 11), p->end());{{$}} + // CHECK-FIXES: p->erase(remove(p->begin(), p->end(), 11), p->end()); std::vector_with_const_iterator<int> v2; v2.erase(remove(v2.begin(), v2.end(), 12)); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one - // CHECK-FIXES: {{^ }}v2.erase(remove(v2.begin(), v2.end(), 12), v2.end());{{$}} + // CHECK-FIXES: v2.erase(remove(v2.begin(), v2.end(), 12), v2.end()); // Fix is not trivial. auto it = v.end(); v.erase(remove(v.begin(), it, 10)); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this call will remove at most one - // CHECK-FIXES: {{^ }}v.erase(remove(v.begin(), it, 10));{{$}} + // CHECK-FIXES: v.erase(remove(v.begin(), it, 10)); g<std::vector<int>>(); g<custom_container>(); ERASE(v, 15); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: this call will remove at most one - // CHECK-FIXES: {{^ }}ERASE(v, 15);{{$}} + // CHECK-FIXES: ERASE(v, 15); std::vector<std::unique_ptr<int>> vupi; auto iter = vupi.begin(); vupi.erase(iter++); - // CHECK-FIXES: {{^ }}vupi.erase(iter++);{{$}} + // CHECK-FIXES: vupi.erase(iter++); } diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-operator-in-strlen-in-alloc.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-operator-in-strlen-in-alloc.cpp index 58d63fa7..bc7b47e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-operator-in-strlen-in-alloc.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-operator-in-strlen-in-alloc.cpp @@ -17,7 +17,7 @@ size_t strlen(const char *); void bad_std_malloc_std_strlen(char *name) { char *new_name = (char *)std::malloc(std::strlen(name + 1)); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: addition operator is applied to the argument of strlen - // CHECK-FIXES: {{^ char \*new_name = \(char \*\)std::malloc\(}}std::strlen(name) + 1{{\);$}} + // CHECK-FIXES: char *new_name = (char *)std::malloc(std::strlen(name) + 1); } void ignore_non_std_malloc_std_strlen(char *name) { @@ -35,7 +35,7 @@ void ignore_std_malloc_non_std_strlen(char *name) { void bad_new_strlen(char *name) { char *new_name = new char[std::strlen(name + 1)]; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: addition operator is applied to the argument of strlen - // CHECK-FIXES: {{^ char \*new_name = new char\[}}std::strlen(name) + 1{{\];$}} + // CHECK-FIXES: char *new_name = new char[std::strlen(name) + 1]; } void good_new_strlen(char *name) { @@ -54,5 +54,5 @@ public: void bad_custom_new_strlen(char *name) { C *new_name = new C[std::strlen(name + 1)]; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: addition operator is applied to the argument of strlen - // CHECK-FIXES: {{^ C \*new_name = new C\[}}std::strlen(name) + 1{{\];$}} + // CHECK-FIXES: C *new_name = new C[std::strlen(name) + 1]; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/reserved-identifier-invert.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/reserved-identifier-invert.cpp index 62ad8de..0dbd744 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/reserved-identifier-invert.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/reserved-identifier-invert.cpp @@ -12,16 +12,16 @@ void __f() {} void f(); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: declaration uses identifier 'f', which is not a reserved identifier [bugprone-reserved-identifier] -// CHECK-FIXES: {{^}}void __f();{{$}} +// CHECK-FIXES: void __f(); struct helper {}; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration uses identifier 'helper', which is not a reserved identifier [bugprone-reserved-identifier] -// CHECK-FIXES: {{^}}struct __helper {};{{$}} +// CHECK-FIXES: struct __helper {}; struct Helper {}; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration uses identifier 'Helper', which is not a reserved identifier [bugprone-reserved-identifier] -// CHECK-FIXES: {{^}}struct _Helper {};{{$}} +// CHECK-FIXES: struct _Helper {}; struct _helper2 {}; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration uses identifier '_helper2', which is not a reserved identifier [bugprone-reserved-identifier] -// CHECK-FIXES: {{^}}struct __helper2 {};{{$}} +// CHECK-FIXES: struct __helper2 {}; template <class _Tp> class reference_wrapper { @@ -53,11 +53,11 @@ ref(reference_wrapper<_Tp> __t) noexcept { template <class Up> // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: declaration uses identifier 'Up', which is not a reserved identifier [bugprone-reserved-identifier] -// CHECK-FIXES: {{^}}template <class _Up>{{$}} +// CHECK-FIXES: template <class _Up> inline reference_wrapper<const Up> cref(const Up &u) noexcept { // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: declaration uses identifier 'u', which is not a reserved identifier [bugprone-reserved-identifier] - // CHECK-FIXES: {{^}}cref(const _Up &__u) noexcept {{{$}} + // CHECK-FIXES: cref(const _Up &__u) noexcept { return reference_wrapper<const Up>(u); } diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/string-integer-assignment.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/string-integer-assignment.cpp index 8db47ea..e127788 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/string-integer-assignment.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/string-integer-assignment.cpp @@ -33,26 +33,26 @@ int main() { s = 6; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: an integer is interpreted as a character code when assigning {{.*}} [bugprone-string-integer-assignment] -// CHECK-FIXES: {{^}} s = '6';{{$}} +// CHECK-FIXES: s = '6'; s = 66; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: an integer is interpreted as a chara -// CHECK-FIXES: {{^}} s = "66";{{$}} +// CHECK-FIXES: s = "66"; s = x; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: an integer is interpreted as a chara -// CHECK-FIXES: {{^}} s = std::to_string(x);{{$}} +// CHECK-FIXES: s = std::to_string(x); s = 'c'; s = static_cast<char>(6); // += ws += 6; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: an integer is interpreted as a chara -// CHECK-FIXES: {{^}} ws += L'6';{{$}} +// CHECK-FIXES: ws += L'6'; ws += 66; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: an integer is interpreted as a chara -// CHECK-FIXES: {{^}} ws += L"66";{{$}} +// CHECK-FIXES: ws += L"66"; ws += x; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: an integer is interpreted as a chara -// CHECK-FIXES: {{^}} ws += std::to_wstring(x);{{$}} +// CHECK-FIXES: ws += std::to_wstring(x); ws += L'c'; ws += (wchar_t)6; @@ -79,11 +79,11 @@ int main() { s += x % 26; s += 26 % x; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: an integer is interpreted as a chara - // CHECK-FIXES: {{^}} s += std::to_string(26 % x);{{$}} + // CHECK-FIXES: s += std::to_string(26 % x); s += c | 0x80; s += c | 0x8000; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: an integer is interpreted as a chara - // CHECK-FIXES: {{^}} s += std::to_string(c | 0x8000);{{$}} + // CHECK-FIXES: s += std::to_string(c | 0x8000); as += c | 0x8000; s += 'a' + (x % 26); @@ -94,7 +94,7 @@ int main() { s += x > 255 ? c : x; s += x > 255 ? 12 : x; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: an integer is interpreted as a chara - // CHECK-FIXES: {{^}} s += std::to_string(x > 255 ? 12 : x);{{$}} + // CHECK-FIXES: s += std::to_string(x > 255 ? 12 : x); } namespace instantiation_dependent_exprs { @@ -104,7 +104,7 @@ struct S { std::string s; void f(char c) { s += c | static_cast<int>(t); } // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: an integer is interpreted as a chara - // CHECK-FIXES: {{^}} void f(char c) { s += std::to_string(c | static_cast<int>(t)); } + // CHECK-FIXES: void f(char c) { s += std::to_string(c | static_cast<int>(t)); } }; template struct S<int>; diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/stringview-nullptr.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/stringview-nullptr.cpp index 129a841..050e38d 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/stringview-nullptr.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/stringview-nullptr.cpp @@ -134,124 +134,124 @@ void temporary_construction() /* a */ { { (void)(std::string_view(nullptr)) /* a1 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor - // CHECK-FIXES: {{^}} (void)(std::string_view()) /* a1 */; + // CHECK-FIXES: (void)(std::string_view()) /* a1 */; (void)(std::string_view((nullptr))) /* a2 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view()) /* a2 */; + // CHECK-FIXES: (void)(std::string_view()) /* a2 */; (void)(std::string_view({nullptr})) /* a3 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view()) /* a3 */; + // CHECK-FIXES: (void)(std::string_view()) /* a3 */; (void)(std::string_view({(nullptr)})) /* a4 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view()) /* a4 */; + // CHECK-FIXES: (void)(std::string_view()) /* a4 */; (void)(std::string_view({})) /* a5 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view()) /* a5 */; + // CHECK-FIXES: (void)(std::string_view()) /* a5 */; } // Temporary Object { (void)(std::string_view{nullptr}) /* a6 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view{}) /* a6 */; + // CHECK-FIXES: (void)(std::string_view{}) /* a6 */; (void)(std::string_view{(nullptr)}) /* a7 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view{}) /* a7 */; + // CHECK-FIXES: (void)(std::string_view{}) /* a7 */; (void)(std::string_view{{nullptr}}) /* a8 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view{}) /* a8 */; + // CHECK-FIXES: (void)(std::string_view{}) /* a8 */; (void)(std::string_view{{(nullptr)}}) /* a9 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view{}) /* a9 */; + // CHECK-FIXES: (void)(std::string_view{}) /* a9 */; (void)(std::string_view{{}}) /* a10 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(std::string_view{}) /* a10 */; + // CHECK-FIXES: (void)(std::string_view{}) /* a10 */; } // C-Style Cast && Compound Literal { (void)((std::string_view) nullptr) /* a11 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view) {}) /* a11 */; + // CHECK-FIXES: (void)((std::string_view) {}) /* a11 */; (void)((std::string_view)(nullptr)) /* a12 */; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view){}) /* a12 */; + // CHECK-FIXES: (void)((std::string_view){}) /* a12 */; (void)((std::string_view){nullptr}) /* a13 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view){}) /* a13 */; + // CHECK-FIXES: (void)((std::string_view){}) /* a13 */; (void)((std::string_view){(nullptr)}) /* a14 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view){}) /* a14 */; + // CHECK-FIXES: (void)((std::string_view){}) /* a14 */; (void)((std::string_view){{nullptr}}) /* a15 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view){}) /* a15 */; + // CHECK-FIXES: (void)((std::string_view){}) /* a15 */; (void)((std::string_view){{(nullptr)}}) /* a16 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view){}) /* a16 */; + // CHECK-FIXES: (void)((std::string_view){}) /* a16 */; (void)((std::string_view){{}}) /* a17 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((std::string_view){}) /* a17 */; + // CHECK-FIXES: (void)((std::string_view){}) /* a17 */; (void)((const std::string_view) nullptr) /* a18 */; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view) {}) /* a18 */; + // CHECK-FIXES: (void)((const std::string_view) {}) /* a18 */; (void)((const std::string_view)(nullptr)) /* a19 */; // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view){}) /* a19 */; + // CHECK-FIXES: (void)((const std::string_view){}) /* a19 */; (void)((const std::string_view){nullptr}) /* a20 */; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view){}) /* a20 */; + // CHECK-FIXES: (void)((const std::string_view){}) /* a20 */; (void)((const std::string_view){(nullptr)}) /* a21 */; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view){}) /* a21 */; + // CHECK-FIXES: (void)((const std::string_view){}) /* a21 */; (void)((const std::string_view){{nullptr}}) /* a22 */; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view){}) /* a22 */; + // CHECK-FIXES: (void)((const std::string_view){}) /* a22 */; (void)((const std::string_view){{(nullptr)}}) /* a23 */; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view){}) /* a23 */; + // CHECK-FIXES: (void)((const std::string_view){}) /* a23 */; (void)((const std::string_view){{}}) /* a24 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)((const std::string_view){}) /* a24 */; + // CHECK-FIXES: (void)((const std::string_view){}) /* a24 */; } // Static Cast { (void)(static_cast<std::string_view>(nullptr)) /* a25 */; // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting to basic_string_view from null is undefined; replace with the empty string - // CHECK-FIXES: {{^}} (void)(static_cast<std::string_view>("")) /* a25 */; + // CHECK-FIXES: (void)(static_cast<std::string_view>("")) /* a25 */; (void)(static_cast<std::string_view>((nullptr))) /* a26 */; // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(static_cast<std::string_view>("")) /* a26 */; + // CHECK-FIXES: (void)(static_cast<std::string_view>("")) /* a26 */; (void)(static_cast<const std::string_view>(nullptr)) /* a27 */; // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(static_cast<const std::string_view>("")) /* a27 */; + // CHECK-FIXES: (void)(static_cast<const std::string_view>("")) /* a27 */; (void)(static_cast<const std::string_view>((nullptr))) /* a28 */; // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(static_cast<const std::string_view>("")) /* a28 */; + // CHECK-FIXES: (void)(static_cast<const std::string_view>("")) /* a28 */; } } @@ -260,240 +260,240 @@ void stack_construction() /* b */ { { std::string_view b1 = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b1 = {}; + // CHECK-FIXES: std::string_view b1 = {}; std::string_view b2 = (nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b2 = {}; + // CHECK-FIXES: std::string_view b2 = {}; const std::string_view b3 = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b3 = {}; + // CHECK-FIXES: const std::string_view b3 = {}; const std::string_view b4 = (nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b4 = {}; + // CHECK-FIXES: const std::string_view b4 = {}; } // Copy Initialization With Temporary { std::string_view b5 = std::string_view(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b5 = std::string_view(); + // CHECK-FIXES: std::string_view b5 = std::string_view(); std::string_view b6 = std::string_view{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b6 = std::string_view{}; + // CHECK-FIXES: std::string_view b6 = std::string_view{}; std::string_view b7 = (std::string_view) nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b7 = (std::string_view) {}; + // CHECK-FIXES: std::string_view b7 = (std::string_view) {}; std::string_view b8 = (std::string_view){nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b8 = (std::string_view){}; + // CHECK-FIXES: std::string_view b8 = (std::string_view){}; std::string_view b9 = static_cast<SV>(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view b9 = static_cast<SV>(""); + // CHECK-FIXES: std::string_view b9 = static_cast<SV>(""); } // Copy List Initialization { std::string_view b10 = {nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b10 = {}; + // CHECK-FIXES: std::string_view b10 = {}; std::string_view b11 = {(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b11 = {}; + // CHECK-FIXES: std::string_view b11 = {}; std::string_view b12 = {{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b12 = {}; + // CHECK-FIXES: std::string_view b12 = {}; std::string_view b13 = {{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b13 = {}; + // CHECK-FIXES: std::string_view b13 = {}; std::string_view b14 = {{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b14 = {}; + // CHECK-FIXES: std::string_view b14 = {}; const std::string_view b15 = {nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b15 = {}; + // CHECK-FIXES: const std::string_view b15 = {}; const std::string_view b16 = {(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b16 = {}; + // CHECK-FIXES: const std::string_view b16 = {}; const std::string_view b17 = {{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b17 = {}; + // CHECK-FIXES: const std::string_view b17 = {}; const std::string_view b18 = {{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b18 = {}; + // CHECK-FIXES: const std::string_view b18 = {}; const std::string_view b19 = {{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b19 = {}; + // CHECK-FIXES: const std::string_view b19 = {}; } // Copy List Initialization With Temporary { std::string_view b20 = {std::string_view(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b20 = {std::string_view()}; + // CHECK-FIXES: std::string_view b20 = {std::string_view()}; std::string_view b21 = {std::string_view{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b21 = {std::string_view{}}; + // CHECK-FIXES: std::string_view b21 = {std::string_view{}}; std::string_view b22 = {(std::string_view) nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b22 = {(std::string_view) {}}; + // CHECK-FIXES: std::string_view b22 = {(std::string_view) {}}; std::string_view b23 = {(std::string_view){nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b23 = {(std::string_view){}}; + // CHECK-FIXES: std::string_view b23 = {(std::string_view){}}; std::string_view b24 = {static_cast<SV>(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view b24 = {static_cast<SV>("")}; + // CHECK-FIXES: std::string_view b24 = {static_cast<SV>("")}; } // Direct Initialization { std::string_view b25(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b25; + // CHECK-FIXES: std::string_view b25; std::string_view b26((nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b26; + // CHECK-FIXES: std::string_view b26; std::string_view b27({nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b27; + // CHECK-FIXES: std::string_view b27; std::string_view b28({(nullptr)}); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b28; + // CHECK-FIXES: std::string_view b28; std::string_view b29({}); // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b29; + // CHECK-FIXES: std::string_view b29; const std::string_view b30(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b30; + // CHECK-FIXES: const std::string_view b30; const std::string_view b31((nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b31; + // CHECK-FIXES: const std::string_view b31; const std::string_view b32({nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b32; + // CHECK-FIXES: const std::string_view b32; const std::string_view b33({(nullptr)}); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b33; + // CHECK-FIXES: const std::string_view b33; const std::string_view b34({}); // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b34; + // CHECK-FIXES: const std::string_view b34; } // Direct Initialization With Temporary { std::string_view b35(std::string_view(nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b35(std::string_view()); + // CHECK-FIXES: std::string_view b35(std::string_view()); std::string_view b36(std::string_view{nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b36(std::string_view{}); + // CHECK-FIXES: std::string_view b36(std::string_view{}); std::string_view b37((std::string_view) nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b37((std::string_view) {}); + // CHECK-FIXES: std::string_view b37((std::string_view) {}); std::string_view b38((std::string_view){nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b38((std::string_view){}); + // CHECK-FIXES: std::string_view b38((std::string_view){}); std::string_view b39(static_cast<SV>(nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view b39(static_cast<SV>("")); + // CHECK-FIXES: std::string_view b39(static_cast<SV>("")); } // Direct List Initialization { std::string_view b40{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b40{}; + // CHECK-FIXES: std::string_view b40{}; std::string_view b41{(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b41{}; + // CHECK-FIXES: std::string_view b41{}; std::string_view b42{{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b42{}; + // CHECK-FIXES: std::string_view b42{}; std::string_view b43{{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b43{}; + // CHECK-FIXES: std::string_view b43{}; std::string_view b44{{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b44{}; + // CHECK-FIXES: std::string_view b44{}; const std::string_view b45{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b45{}; + // CHECK-FIXES: const std::string_view b45{}; const std::string_view b46{(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b46{}; + // CHECK-FIXES: const std::string_view b46{}; const std::string_view b47{{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b47{}; + // CHECK-FIXES: const std::string_view b47{}; const std::string_view b48{{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b48{}; + // CHECK-FIXES: const std::string_view b48{}; const std::string_view b49{{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view b49{}; + // CHECK-FIXES: const std::string_view b49{}; } // Direct List Initialization With Temporary { std::string_view b50{std::string_view(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b50{std::string_view()}; + // CHECK-FIXES: std::string_view b50{std::string_view()}; std::string_view b51{std::string_view{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b51{std::string_view{}}; + // CHECK-FIXES: std::string_view b51{std::string_view{}}; std::string_view b52{(std::string_view) nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b52{(std::string_view) {}}; + // CHECK-FIXES: std::string_view b52{(std::string_view) {}}; std::string_view b53{(std::string_view){nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view b53{(std::string_view){}}; + // CHECK-FIXES: std::string_view b53{(std::string_view){}}; std::string_view b54{static_cast<SV>(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view b54{static_cast<SV>("")}; + // CHECK-FIXES: std::string_view b54{static_cast<SV>("")}; } } @@ -503,169 +503,169 @@ void field_construction() /* c */ { struct DMICopyInitialization { std::string_view c1 = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c1 = {}; + // CHECK-FIXES: std::string_view c1 = {}; std::string_view c2 = (nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c2 = {}; + // CHECK-FIXES: std::string_view c2 = {}; const std::string_view c3 = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c3 = {}; + // CHECK-FIXES: const std::string_view c3 = {}; const std::string_view c4 = (nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c4 = {}; + // CHECK-FIXES: const std::string_view c4 = {}; }; struct DMICopyInitializationWithTemporary { std::string_view c5 = std::string_view(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c5 = std::string_view(); + // CHECK-FIXES: std::string_view c5 = std::string_view(); std::string_view c6 = std::string_view{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c6 = std::string_view{}; + // CHECK-FIXES: std::string_view c6 = std::string_view{}; std::string_view c7 = (std::string_view) nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c7 = (std::string_view) {}; + // CHECK-FIXES: std::string_view c7 = (std::string_view) {}; std::string_view c8 = (std::string_view){nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c8 = (std::string_view){}; + // CHECK-FIXES: std::string_view c8 = (std::string_view){}; std::string_view c9 = static_cast<SV>(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view c9 = static_cast<SV>(""); + // CHECK-FIXES: std::string_view c9 = static_cast<SV>(""); }; struct DMICopyListInitialization { std::string_view c10 = {nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c10 = {}; + // CHECK-FIXES: std::string_view c10 = {}; std::string_view c11 = {(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c11 = {}; + // CHECK-FIXES: std::string_view c11 = {}; std::string_view c12 = {{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c12 = {}; + // CHECK-FIXES: std::string_view c12 = {}; std::string_view c13 = {{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c13 = {}; + // CHECK-FIXES: std::string_view c13 = {}; std::string_view c14 = {{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c14 = {}; + // CHECK-FIXES: std::string_view c14 = {}; const std::string_view c15 = {nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c15 = {}; + // CHECK-FIXES: const std::string_view c15 = {}; const std::string_view c16 = {(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c16 = {}; + // CHECK-FIXES: const std::string_view c16 = {}; const std::string_view c17 = {{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c17 = {}; + // CHECK-FIXES: const std::string_view c17 = {}; const std::string_view c18 = {{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c18 = {}; + // CHECK-FIXES: const std::string_view c18 = {}; const std::string_view c19 = {{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c19 = {}; + // CHECK-FIXES: const std::string_view c19 = {}; }; struct DMICopyListInitializationWithTemporary { std::string_view c20 = {std::string_view(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c20 = {std::string_view()}; + // CHECK-FIXES: std::string_view c20 = {std::string_view()}; std::string_view c21 = {std::string_view{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c21 = {std::string_view{}}; + // CHECK-FIXES: std::string_view c21 = {std::string_view{}}; std::string_view c22 = {(std::string_view) nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c22 = {(std::string_view) {}}; + // CHECK-FIXES: std::string_view c22 = {(std::string_view) {}}; std::string_view c23 = {(std::string_view){nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c23 = {(std::string_view){}}; + // CHECK-FIXES: std::string_view c23 = {(std::string_view){}}; std::string_view c24 = {static_cast<SV>(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view c24 = {static_cast<SV>("")}; + // CHECK-FIXES: std::string_view c24 = {static_cast<SV>("")}; }; struct DMIDirectListInitialization { std::string_view c25{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c25{}; + // CHECK-FIXES: std::string_view c25{}; std::string_view c26{(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c26{}; + // CHECK-FIXES: std::string_view c26{}; std::string_view c27{{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c27{}; + // CHECK-FIXES: std::string_view c27{}; std::string_view c28{{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c28{}; + // CHECK-FIXES: std::string_view c28{}; std::string_view c29{{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c29{}; + // CHECK-FIXES: std::string_view c29{}; const std::string_view c30{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c30{}; + // CHECK-FIXES: const std::string_view c30{}; const std::string_view c31{(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c31{}; + // CHECK-FIXES: const std::string_view c31{}; const std::string_view c32{{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c32{}; + // CHECK-FIXES: const std::string_view c32{}; const std::string_view c33{{(nullptr)}}; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c33{}; + // CHECK-FIXES: const std::string_view c33{}; const std::string_view c34{{}}; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} const std::string_view c34{}; + // CHECK-FIXES: const std::string_view c34{}; }; struct DMIDirectListInitializationWithTemporary { std::string_view c35{std::string_view(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c35{std::string_view()}; + // CHECK-FIXES: std::string_view c35{std::string_view()}; std::string_view c36{std::string_view{nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c36{std::string_view{}}; + // CHECK-FIXES: std::string_view c36{std::string_view{}}; std::string_view c37{(std::string_view) nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c37{(std::string_view) {}}; + // CHECK-FIXES: std::string_view c37{(std::string_view) {}}; std::string_view c38{(std::string_view){nullptr}}; // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} std::string_view c38{(std::string_view){}}; + // CHECK-FIXES: std::string_view c38{(std::string_view){}}; std::string_view c39{static_cast<SV>(nullptr)}; // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} std::string_view c39{static_cast<SV>("")}; + // CHECK-FIXES: std::string_view c39{static_cast<SV>("")}; }; // Constructor Initializers @@ -680,23 +680,23 @@ void field_construction() /* c */ { CIDirectInitialization() : c40(nullptr), // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} : c40(), + // CHECK-FIXES: : c40(), c41((nullptr)), // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c41(), + // CHECK-FIXES: c41(), c42({nullptr}), // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c42(), + // CHECK-FIXES: c42(), c43({(nullptr)}), // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c43(), + // CHECK-FIXES: c43(), c44({}) { // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c44() { + // CHECK-FIXES: c44() { } }; @@ -710,23 +710,23 @@ void field_construction() /* c */ { CIDirectInitializationWithTemporary() : c45(std::string_view(nullptr)), // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} : c45(std::string_view()), + // CHECK-FIXES: : c45(std::string_view()), c46(std::string_view{nullptr}), // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c46(std::string_view{}), + // CHECK-FIXES: c46(std::string_view{}), c47((std::string_view) nullptr), // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c47((std::string_view) {}), + // CHECK-FIXES: c47((std::string_view) {}), c48((std::string_view){nullptr}), // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c48((std::string_view){}), + // CHECK-FIXES: c48((std::string_view){}), c49(static_cast<SV>(nullptr)) { // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} c49(static_cast<SV>("")) { + // CHECK-FIXES: c49(static_cast<SV>("")) { } }; @@ -740,23 +740,23 @@ void field_construction() /* c */ { CIDirectListInitialization() : c50{nullptr}, // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} : c50{}, + // CHECK-FIXES: : c50{}, c51{(nullptr)}, // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c51{}, + // CHECK-FIXES: c51{}, c52{{nullptr}}, // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c52{}, + // CHECK-FIXES: c52{}, c53{{(nullptr)}}, // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c53{}, + // CHECK-FIXES: c53{}, c54{{}} { // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c54{} { + // CHECK-FIXES: c54{} { } }; @@ -770,23 +770,23 @@ void field_construction() /* c */ { CIDirectListInitializationWithTemporary() : c55{std::string_view(nullptr)}, // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} : c55{std::string_view()}, + // CHECK-FIXES: : c55{std::string_view()}, c56{std::string_view{nullptr}}, // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c56{std::string_view{}}, + // CHECK-FIXES: c56{std::string_view{}}, c57{(std::string_view) nullptr}, // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c57{(std::string_view) {}}, + // CHECK-FIXES: c57{(std::string_view) {}}, c58{(std::string_view){nullptr}}, // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} c58{(std::string_view){}}, + // CHECK-FIXES: c58{(std::string_view){}}, c59{static_cast<SV>(nullptr)} { // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} c59{static_cast<SV>("")} { + // CHECK-FIXES: c59{static_cast<SV>("")} { } }; } @@ -796,108 +796,108 @@ void default_argument_construction() /* d */ { { void d1(std::string_view sv = nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d1(std::string_view sv = {}); + // CHECK-FIXES: void d1(std::string_view sv = {}); void d2(std::string_view sv = (nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d2(std::string_view sv = {}); + // CHECK-FIXES: void d2(std::string_view sv = {}); void d3(const std::string_view sv = nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d3(const std::string_view sv = {}); + // CHECK-FIXES: void d3(const std::string_view sv = {}); void d4(const std::string_view sv = (nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d4(const std::string_view sv = {}); + // CHECK-FIXES: void d4(const std::string_view sv = {}); } // Copy Initialization With Temporary { void d5(std::string_view sv = std::string_view(nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d5(std::string_view sv = std::string_view()); + // CHECK-FIXES: void d5(std::string_view sv = std::string_view()); void d6(std::string_view sv = std::string_view{nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d6(std::string_view sv = std::string_view{}); + // CHECK-FIXES: void d6(std::string_view sv = std::string_view{}); void d7(std::string_view sv = (std::string_view) nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d7(std::string_view sv = (std::string_view) {}); + // CHECK-FIXES: void d7(std::string_view sv = (std::string_view) {}); void d8(std::string_view sv = (std::string_view){nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d8(std::string_view sv = (std::string_view){}); + // CHECK-FIXES: void d8(std::string_view sv = (std::string_view){}); void d9(std::string_view sv = static_cast<SV>(nullptr)); // CHECK-MESSAGES: :[[@LINE-1]]:51: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} void d9(std::string_view sv = static_cast<SV>("")); + // CHECK-FIXES: void d9(std::string_view sv = static_cast<SV>("")); } // Copy List Initialization { void d10(std::string_view sv = {nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d10(std::string_view sv = {}); + // CHECK-FIXES: void d10(std::string_view sv = {}); void d11(std::string_view sv = {(nullptr)}); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d11(std::string_view sv = {}); + // CHECK-FIXES: void d11(std::string_view sv = {}); void d12(std::string_view sv = {{nullptr}}); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d12(std::string_view sv = {}); + // CHECK-FIXES: void d12(std::string_view sv = {}); void d13(std::string_view sv = {{(nullptr)}}); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d13(std::string_view sv = {}); + // CHECK-FIXES: void d13(std::string_view sv = {}); void d14(std::string_view sv = {{}}); // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d14(std::string_view sv = {}); + // CHECK-FIXES: void d14(std::string_view sv = {}); void d15(const std::string_view sv = {nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d15(const std::string_view sv = {}); + // CHECK-FIXES: void d15(const std::string_view sv = {}); void d16(const std::string_view sv = {(nullptr)}); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d16(const std::string_view sv = {}); + // CHECK-FIXES: void d16(const std::string_view sv = {}); void d17(const std::string_view sv = {{nullptr}}); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d17(const std::string_view sv = {}); + // CHECK-FIXES: void d17(const std::string_view sv = {}); void d18(const std::string_view sv = {{(nullptr)}}); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d18(const std::string_view sv = {}); + // CHECK-FIXES: void d18(const std::string_view sv = {}); void d19(const std::string_view sv = {{}}); // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d19(const std::string_view sv = {}); + // CHECK-FIXES: void d19(const std::string_view sv = {}); } // Copy List Initialization With Temporary { void d20(std::string_view sv = {std::string_view(nullptr)}); // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d20(std::string_view sv = {std::string_view()}); + // CHECK-FIXES: void d20(std::string_view sv = {std::string_view()}); void d21(std::string_view sv = {std::string_view{nullptr}}); // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d21(std::string_view sv = {std::string_view{}}); + // CHECK-FIXES: void d21(std::string_view sv = {std::string_view{}}); void d22(std::string_view sv = {(std::string_view) nullptr}); // CHECK-MESSAGES: :[[@LINE-1]]:56: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d22(std::string_view sv = {(std::string_view) {}}); + // CHECK-FIXES: void d22(std::string_view sv = {(std::string_view) {}}); void d23(std::string_view sv = {(std::string_view){nullptr}}); // CHECK-MESSAGES: :[[@LINE-1]]:56: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} void d23(std::string_view sv = {(std::string_view){}}); + // CHECK-FIXES: void d23(std::string_view sv = {(std::string_view){}}); void d24(std::string_view sv = {static_cast<SV>(nullptr)}); // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} void d24(std::string_view sv = {static_cast<SV>("")}); + // CHECK-FIXES: void d24(std::string_view sv = {static_cast<SV>("")}); } } @@ -906,132 +906,132 @@ void heap_construction() /* e */ { { (void)(new std::string_view(nullptr)) /* e1 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view()) /* e1 */; + // CHECK-FIXES: (void)(new std::string_view()) /* e1 */; (void)(new std::string_view((nullptr))) /* e2 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view()) /* e2 */; + // CHECK-FIXES: (void)(new std::string_view()) /* e2 */; (void)(new std::string_view({nullptr})) /* e3 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view()) /* e3 */; + // CHECK-FIXES: (void)(new std::string_view()) /* e3 */; (void)(new std::string_view({(nullptr)})) /* e4 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view()) /* e4 */; + // CHECK-FIXES: (void)(new std::string_view()) /* e4 */; (void)(new std::string_view({})) /* e5 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view()) /* e5 */; + // CHECK-FIXES: (void)(new std::string_view()) /* e5 */; (void)(new const std::string_view(nullptr)) /* e6 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view()) /* e6 */; + // CHECK-FIXES: (void)(new const std::string_view()) /* e6 */; (void)(new const std::string_view((nullptr))) /* e7 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view()) /* e7 */; + // CHECK-FIXES: (void)(new const std::string_view()) /* e7 */; (void)(new const std::string_view({nullptr})) /* e8 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view()) /* e8 */; + // CHECK-FIXES: (void)(new const std::string_view()) /* e8 */; (void)(new const std::string_view({(nullptr)})) /* e9 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view()) /* e9 */; + // CHECK-FIXES: (void)(new const std::string_view()) /* e9 */; (void)(new const std::string_view({})) /* e10 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view()) /* e10 */; + // CHECK-FIXES: (void)(new const std::string_view()) /* e10 */; } // Direct Initialization With Temporary { (void)(new std::string_view(std::string_view(nullptr))) /* e11 */; // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view(std::string_view())) /* e11 */; + // CHECK-FIXES: (void)(new std::string_view(std::string_view())) /* e11 */; (void)(new std::string_view(std::string_view{nullptr})) /* e12 */; // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view(std::string_view{})) /* e12 */; + // CHECK-FIXES: (void)(new std::string_view(std::string_view{})) /* e12 */; (void)(new std::string_view((std::string_view) nullptr)) /* e13 */; // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view((std::string_view) {})) /* e13 */; + // CHECK-FIXES: (void)(new std::string_view((std::string_view) {})) /* e13 */; (void)(new std::string_view((std::string_view){nullptr})) /* e14 */; // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view((std::string_view){})) /* e14 */; + // CHECK-FIXES: (void)(new std::string_view((std::string_view){})) /* e14 */; (void)(new std::string_view(static_cast<SV>(nullptr))) /* e15 */; // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(new std::string_view(static_cast<SV>(""))) /* e15 */; + // CHECK-FIXES: (void)(new std::string_view(static_cast<SV>(""))) /* e15 */; } // Direct List Initialization { (void)(new std::string_view{nullptr}) /* e16 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e16 */; + // CHECK-FIXES: (void)(new std::string_view{}) /* e16 */; (void)(new std::string_view{(nullptr)}) /* e17 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e17 */; + // CHECK-FIXES: (void)(new std::string_view{}) /* e17 */; (void)(new std::string_view{{nullptr}}) /* e18 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e18 */; + // CHECK-FIXES: (void)(new std::string_view{}) /* e18 */; (void)(new std::string_view{{(nullptr)}}) /* e19 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e19 */; + // CHECK-FIXES: (void)(new std::string_view{}) /* e19 */; (void)(new std::string_view{{}}) /* e20 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e20 */; + // CHECK-FIXES: (void)(new std::string_view{}) /* e20 */; (void)(new const std::string_view{nullptr}) /* e21 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e21 */; + // CHECK-FIXES: (void)(new const std::string_view{}) /* e21 */; (void)(new const std::string_view{(nullptr)}) /* e22 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e22 */; + // CHECK-FIXES: (void)(new const std::string_view{}) /* e22 */; (void)(new const std::string_view{{nullptr}}) /* e23 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e23 */; + // CHECK-FIXES: (void)(new const std::string_view{}) /* e23 */; (void)(new const std::string_view{{(nullptr)}}) /* e24 */; // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e24 */; + // CHECK-FIXES: (void)(new const std::string_view{}) /* e24 */; (void)(new const std::string_view{{}}) /* e25 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e25 */; + // CHECK-FIXES: (void)(new const std::string_view{}) /* e25 */; } // Direct List Initialization With Temporary { (void)(new std::string_view{std::string_view(nullptr)}) /* e26 */; // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{std::string_view()}) /* e26 */; + // CHECK-FIXES: (void)(new std::string_view{std::string_view()}) /* e26 */; (void)(new std::string_view{std::string_view{nullptr}}) /* e27 */; // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{std::string_view{}}) /* e27 */; + // CHECK-FIXES: (void)(new std::string_view{std::string_view{}}) /* e27 */; (void)(new std::string_view{(std::string_view) nullptr}) /* e28 */; // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{(std::string_view) {}}) /* e28 */; + // CHECK-FIXES: (void)(new std::string_view{(std::string_view) {}}) /* e28 */; (void)(new std::string_view{(std::string_view){nullptr}}) /* e29 */; // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(new std::string_view{(std::string_view){}}) /* e29 */; + // CHECK-FIXES: (void)(new std::string_view{(std::string_view){}}) /* e29 */; (void)(new std::string_view{static_cast<SV>(nullptr)}) /* e30 */; // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(new std::string_view{static_cast<SV>("")}) /* e30 */; + // CHECK-FIXES: (void)(new std::string_view{static_cast<SV>("")}) /* e30 */; } } @@ -1040,46 +1040,46 @@ void function_argument_initialization() /* f */ { { function(nullptr) /* f1 */; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: passing null as basic_string_view is undefined; replace with the empty string - // CHECK-FIXES: {{^}} function("") /* f1 */; + // CHECK-FIXES: function("") /* f1 */; function((nullptr)) /* f2 */; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} function("") /* f2 */; + // CHECK-FIXES: function("") /* f2 */; function({nullptr}) /* f3 */; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} function("") /* f3 */; + // CHECK-FIXES: function("") /* f3 */; function({(nullptr)}) /* f4 */; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} function("") /* f4 */; + // CHECK-FIXES: function("") /* f4 */; function({{}}) /* f5 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} function("") /* f5 */; + // CHECK-FIXES: function("") /* f5 */; } // Function Argument Initialization With Temporary { function(std::string_view(nullptr)) /* f6 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} function(std::string_view()) /* f6 */; + // CHECK-FIXES: function(std::string_view()) /* f6 */; function(std::string_view{nullptr}) /* f7 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} function(std::string_view{}) /* f7 */; + // CHECK-FIXES: function(std::string_view{}) /* f7 */; function((std::string_view) nullptr) /* f8 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} function((std::string_view) {}) /* f8 */; + // CHECK-FIXES: function((std::string_view) {}) /* f8 */; function((std::string_view){nullptr}) /* f9 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} function((std::string_view){}) /* f9 */; + // CHECK-FIXES: function((std::string_view){}) /* f9 */; function(static_cast<SV>(nullptr)) /* f10 */; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} function(static_cast<SV>("")) /* f10 */; + // CHECK-FIXES: function(static_cast<SV>("")) /* f10 */; } } @@ -1088,46 +1088,46 @@ void assignment(std::string_view sv) /* g */ { { sv = nullptr /* g1 */; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment to basic_string_view from null is undefined; replace with the default constructor - // CHECK-FIXES: {{^}} sv = {} /* g1 */; + // CHECK-FIXES: sv = {} /* g1 */; sv = (nullptr) /* g2 */; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} sv = {} /* g2 */; + // CHECK-FIXES: sv = {} /* g2 */; sv = {nullptr} /* g3 */; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} sv = {} /* g3 */; + // CHECK-FIXES: sv = {} /* g3 */; sv = {(nullptr)} /* g4 */; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} sv = {} /* g4 */; + // CHECK-FIXES: sv = {} /* g4 */; sv = {{}} /* g5 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} sv = {} /* g5 */; + // CHECK-FIXES: sv = {} /* g5 */; } // Assignment With Temporary { sv = std::string_view(nullptr) /* g6 */; // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} sv = std::string_view() /* g6 */; + // CHECK-FIXES: sv = std::string_view() /* g6 */; sv = std::string_view{nullptr} /* g7 */; // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} sv = std::string_view{} /* g7 */; + // CHECK-FIXES: sv = std::string_view{} /* g7 */; sv = (std::string_view) nullptr /* g8 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} sv = (std::string_view) {} /* g8 */; + // CHECK-FIXES: sv = (std::string_view) {} /* g8 */; sv = (std::string_view){nullptr} /* g9 */; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} sv = (std::string_view){} /* g9 */; + // CHECK-FIXES: sv = (std::string_view){} /* g9 */; sv = static_cast<SV>(nullptr) /* g10 */; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} sv = static_cast<SV>("") /* g10 */; + // CHECK-FIXES: sv = static_cast<SV>("") /* g10 */; } } @@ -1136,46 +1136,46 @@ void pointer_assignment(std::string_view *sv_ptr) /* h */ { { *sv_ptr = nullptr /* h1 */; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = {} /* h1 */; + // CHECK-FIXES: *sv_ptr = {} /* h1 */; *sv_ptr = (nullptr) /* h2 */; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = {} /* h2 */; + // CHECK-FIXES: *sv_ptr = {} /* h2 */; *sv_ptr = {nullptr} /* h3 */; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = {} /* h3 */; + // CHECK-FIXES: *sv_ptr = {} /* h3 */; *sv_ptr = {(nullptr)} /* h4 */; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = {} /* h4 */; + // CHECK-FIXES: *sv_ptr = {} /* h4 */; *sv_ptr = {{}} /* h5 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = {} /* h5 */; + // CHECK-FIXES: *sv_ptr = {} /* h5 */; } // Assignment With Temporary { *sv_ptr = std::string_view(nullptr) /* h6 */; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = std::string_view() /* h6 */; + // CHECK-FIXES: *sv_ptr = std::string_view() /* h6 */; *sv_ptr = std::string_view{nullptr} /* h7 */; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = std::string_view{} /* h7 */; + // CHECK-FIXES: *sv_ptr = std::string_view{} /* h7 */; *sv_ptr = (std::string_view) nullptr /* h8 */; // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = (std::string_view) {} /* h8 */; + // CHECK-FIXES: *sv_ptr = (std::string_view) {} /* h8 */; *sv_ptr = (std::string_view){nullptr} /* h9 */; // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} *sv_ptr = (std::string_view){} /* h9 */; + // CHECK-FIXES: *sv_ptr = (std::string_view){} /* h9 */; *sv_ptr = static_cast<SV>(nullptr) /* h10 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} *sv_ptr = static_cast<SV>("") /* h10 */; + // CHECK-FIXES: *sv_ptr = static_cast<SV>("") /* h10 */; } } @@ -1184,38 +1184,38 @@ void lesser_comparison(std::string_view sv) /* i */ { { (void)(sv < nullptr) /* i1 */; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing basic_string_view to null is undefined; replace with the empty string - // CHECK-FIXES: {{^}} (void)(sv < "") /* i1 */; + // CHECK-FIXES: (void)(sv < "") /* i1 */; (void)(sv < (nullptr)) /* i2 */; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv < "") /* i2 */; + // CHECK-FIXES: (void)(sv < "") /* i2 */; (void)(nullptr < sv) /* i3 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" < sv) /* i3 */; + // CHECK-FIXES: (void)("" < sv) /* i3 */; (void)((nullptr) < sv) /* i4 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" < sv) /* i4 */; + // CHECK-FIXES: (void)("" < sv) /* i4 */; } // With Equality { (void)(sv <= nullptr) /* i5 */; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv <= "") /* i5 */; + // CHECK-FIXES: (void)(sv <= "") /* i5 */; (void)(sv <= (nullptr)) /* i6 */; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv <= "") /* i6 */; + // CHECK-FIXES: (void)(sv <= "") /* i6 */; (void)(nullptr <= sv) /* i7 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" <= sv) /* i7 */; + // CHECK-FIXES: (void)("" <= sv) /* i7 */; (void)((nullptr) <= sv) /* i8 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" <= sv) /* i8 */; + // CHECK-FIXES: (void)("" <= sv) /* i8 */; } } @@ -1224,38 +1224,38 @@ void pointer_lesser_comparison(std::string_view *sv_ptr) /* j */ { { (void)(*sv_ptr < nullptr) /* j1 */; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr < "") /* j1 */; + // CHECK-FIXES: (void)(*sv_ptr < "") /* j1 */; (void)(*sv_ptr < (nullptr)) /* j2 */; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr < "") /* j2 */; + // CHECK-FIXES: (void)(*sv_ptr < "") /* j2 */; (void)(nullptr < *sv_ptr) /* j3 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" < *sv_ptr) /* j3 */; + // CHECK-FIXES: (void)("" < *sv_ptr) /* j3 */; (void)((nullptr) < *sv_ptr) /* j4 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" < *sv_ptr) /* j4 */; + // CHECK-FIXES: (void)("" < *sv_ptr) /* j4 */; } // With Equality { (void)(*sv_ptr <= nullptr) /* j5 */; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr <= "") /* j5 */; + // CHECK-FIXES: (void)(*sv_ptr <= "") /* j5 */; (void)(*sv_ptr <= (nullptr)) /* j6 */; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr <= "") /* j6 */; + // CHECK-FIXES: (void)(*sv_ptr <= "") /* j6 */; (void)(nullptr <= *sv_ptr) /* j7 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" <= *sv_ptr) /* j7 */; + // CHECK-FIXES: (void)("" <= *sv_ptr) /* j7 */; (void)((nullptr) <= *sv_ptr) /* j8 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" <= *sv_ptr) /* j8 */; + // CHECK-FIXES: (void)("" <= *sv_ptr) /* j8 */; } } @@ -1264,38 +1264,38 @@ void greater_comparison(std::string_view sv) /* k */ { { (void)(sv > nullptr) /* k1 */; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv > "") /* k1 */; + // CHECK-FIXES: (void)(sv > "") /* k1 */; (void)(sv > (nullptr)) /* k2 */; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv > "") /* k2 */; + // CHECK-FIXES: (void)(sv > "") /* k2 */; (void)(nullptr > sv) /* k3 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" > sv) /* k3 */; + // CHECK-FIXES: (void)("" > sv) /* k3 */; (void)((nullptr) > sv) /* k4 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" > sv) /* k4 */; + // CHECK-FIXES: (void)("" > sv) /* k4 */; } // With Equality { (void)(sv >= nullptr) /* k5 */; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv >= "") /* k5 */; + // CHECK-FIXES: (void)(sv >= "") /* k5 */; (void)(sv >= (nullptr)) /* k6 */; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv >= "") /* k6 */; + // CHECK-FIXES: (void)(sv >= "") /* k6 */; (void)(nullptr >= sv) /* k7 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" >= sv) /* k7 */; + // CHECK-FIXES: (void)("" >= sv) /* k7 */; (void)((nullptr) >= sv) /* k8 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" >= sv) /* k8 */; + // CHECK-FIXES: (void)("" >= sv) /* k8 */; } } @@ -1304,61 +1304,61 @@ void pointer_greater_comparison(std::string_view *sv_ptr) /* l */ { { (void)(*sv_ptr > nullptr) /* l1 */; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr > "") /* l1 */; + // CHECK-FIXES: (void)(*sv_ptr > "") /* l1 */; (void)(*sv_ptr > (nullptr)) /* l2 */; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr > "") /* l2 */; + // CHECK-FIXES: (void)(*sv_ptr > "") /* l2 */; (void)(nullptr > *sv_ptr) /* l3 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" > *sv_ptr) /* l3 */; + // CHECK-FIXES: (void)("" > *sv_ptr) /* l3 */; (void)((nullptr) > *sv_ptr) /* l4 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" > *sv_ptr) /* l4 */; + // CHECK-FIXES: (void)("" > *sv_ptr) /* l4 */; } // With Equality { (void)(*sv_ptr >= nullptr) /* l5 */; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr >= "") /* l5 */; + // CHECK-FIXES: (void)(*sv_ptr >= "") /* l5 */; (void)(*sv_ptr >= (nullptr)) /* l6 */; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(*sv_ptr >= "") /* l6 */; + // CHECK-FIXES: (void)(*sv_ptr >= "") /* l6 */; (void)(nullptr >= *sv_ptr) /* l7 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" >= *sv_ptr) /* l7 */; + // CHECK-FIXES: (void)("" >= *sv_ptr) /* l7 */; (void)((nullptr) >= *sv_ptr) /* l8 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)("" >= *sv_ptr) /* l8 */; + // CHECK-FIXES: (void)("" >= *sv_ptr) /* l8 */; } } void relative_comparison_with_temporary(std::string_view sv) /* m */ { (void)(sv < std::string_view(nullptr)) /* m1 */; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv < std::string_view()) /* m1 */; + // CHECK-FIXES: (void)(sv < std::string_view()) /* m1 */; (void)(sv < std::string_view{nullptr}) /* m2 */; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv < std::string_view{}) /* m2 */; + // CHECK-FIXES: (void)(sv < std::string_view{}) /* m2 */; (void)(sv < (std::string_view) nullptr) /* m3 */; // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv < (std::string_view) {}) /* m3 */; + // CHECK-FIXES: (void)(sv < (std::string_view) {}) /* m3 */; (void)(sv < (std::string_view){nullptr}) /* m4 */; // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv < (std::string_view){}) /* m4 */; + // CHECK-FIXES: (void)(sv < (std::string_view){}) /* m4 */; (void)(sv < static_cast<SV>(nullptr)) /* m5 */; // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv < static_cast<SV>("")) /* m5 */; + // CHECK-FIXES: (void)(sv < static_cast<SV>("")) /* m5 */; } void equality_comparison(std::string_view sv) /* n */ { @@ -1366,76 +1366,76 @@ void equality_comparison(std::string_view sv) /* n */ { { (void)(sv == nullptr) /* n1 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n1 */; + // CHECK-FIXES: (void)(sv.empty()) /* n1 */; (void)(sv == (nullptr)) /* n2 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n2 */; + // CHECK-FIXES: (void)(sv.empty()) /* n2 */; (void)(nullptr == sv) /* n3 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n3 */; + // CHECK-FIXES: (void)(sv.empty()) /* n3 */; (void)((nullptr) == sv) /* n4 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n4 */; + // CHECK-FIXES: (void)(sv.empty()) /* n4 */; } // Empty With Parens { (void)((sv) == nullptr) /* n5 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n5 */; + // CHECK-FIXES: (void)(sv.empty()) /* n5 */; (void)((sv) == (nullptr)) /* n6 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n6 */; + // CHECK-FIXES: (void)(sv.empty()) /* n6 */; (void)(nullptr == (sv)) /* n7 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n7 */; + // CHECK-FIXES: (void)(sv.empty()) /* n7 */; (void)((nullptr) == (sv)) /* n8 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n8 */; + // CHECK-FIXES: (void)(sv.empty()) /* n8 */; } // Non-Empty Without Parens { (void)((sv) != nullptr) /* n9 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n9 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n9 */; (void)((sv) != (nullptr)) /* n10 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n10 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n10 */; (void)(nullptr != (sv)) /* n11 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n11 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n11 */; (void)((nullptr) != (sv)) /* n12 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n12 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n12 */; } // Non-Empty With Parens { (void)((sv) != nullptr) /* n13 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n13 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n13 */; (void)((sv) != (nullptr)) /* n14 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n14 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n14 */; (void)(nullptr != (sv)) /* n15 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n15 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n15 */; (void)((nullptr) != (sv)) /* n16 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n16 */; + // CHECK-FIXES: (void)(!sv.empty()) /* n16 */; } } @@ -1444,99 +1444,99 @@ void pointer_equality_comparison(std::string_view *sv_ptr) /* o */ { { (void)(*sv_ptr == nullptr) /* o1 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o1 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o1 */; (void)(*sv_ptr == (nullptr)) /* o2 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o2 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o2 */; (void)(nullptr == *sv_ptr) /* o3 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o3 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o3 */; (void)((nullptr) == *sv_ptr) /* o4 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o4 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o4 */; } // Empty With Parens { (void)((*sv_ptr) == nullptr) /* o5 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o5 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o5 */; (void)((*sv_ptr) == (nullptr)) /* o6 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o6 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o6 */; (void)(nullptr == (*sv_ptr)) /* o7 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o7 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o7 */; (void)((nullptr) == (*sv_ptr)) /* o8 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o8 */; + // CHECK-FIXES: (void)(sv_ptr->empty()) /* o8 */; } // Non-Empty With Parens { (void)((*sv_ptr) != nullptr) /* o9 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o9 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o9 */; (void)((*sv_ptr) != (nullptr)) /* o10 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o10 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o10 */; (void)(nullptr != (*sv_ptr)) /* o11 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o11 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o11 */; (void)((nullptr) != (*sv_ptr)) /* o12 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o12 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o12 */; } // Non-Empty Without Parens { (void)((*sv_ptr) != nullptr) /* o13 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o13 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o13 */; (void)((*sv_ptr) != (nullptr)) /* o14 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o14 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o14 */; (void)(nullptr != (*sv_ptr)) /* o15 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o15 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o15 */; (void)((nullptr) != (*sv_ptr)) /* o16 */; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query - // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o16 */; + // CHECK-FIXES: (void)(!sv_ptr->empty()) /* o16 */; } } void equality_comparison_with_temporary(std::string_view sv) /* p */ { (void)(sv == std::string_view(nullptr)) /* p1 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv == std::string_view()) /* p1 */; + // CHECK-FIXES: (void)(sv == std::string_view()) /* p1 */; (void)(sv == std::string_view{nullptr}) /* p2 */; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv == std::string_view{}) /* p2 */; + // CHECK-FIXES: (void)(sv == std::string_view{}) /* p2 */; (void)(sv == (std::string_view) nullptr) /* p3 */; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv == (std::string_view) {}) /* p3 */; + // CHECK-FIXES: (void)(sv == (std::string_view) {}) /* p3 */; (void)(sv == (std::string_view){nullptr}) /* p4 */; // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} (void)(sv == (std::string_view){}) /* p4 */; + // CHECK-FIXES: (void)(sv == (std::string_view){}) /* p4 */; (void)(sv == static_cast<SV>(nullptr)) /* p5 */; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(sv == static_cast<SV>("")) /* p5 */; + // CHECK-FIXES: (void)(sv == static_cast<SV>("")) /* p5 */; } void return_statement() /* q */ { @@ -1544,54 +1544,54 @@ void return_statement() /* q */ { { []() -> SV { return nullptr; } /* q1 */; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q1 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q1 */; []() -> SV { return (nullptr); } /* q2 */; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q2 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q2 */; []() -> SV { return {nullptr}; } /* q3 */; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q3 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q3 */; []() -> SV { return {(nullptr)}; } /* q4 */; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q4 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q4 */; []() -> SV { return {{nullptr}}; } /* q5 */; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q5 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q5 */; []() -> SV { return {{(nullptr)}}; } /* q6 */; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q6 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q6 */; []() -> SV { return {{}}; } /* q7 */; // Default `const CharT*` // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q7 */; + // CHECK-FIXES: []() -> SV { return {}; } /* q7 */; } // Return Statement With Temporary { []() -> SV { return SV(nullptr); } /* q8 */; // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return SV(); } /* q8 */; + // CHECK-FIXES: []() -> SV { return SV(); } /* q8 */; []() -> SV { return SV{nullptr}; } /* q9 */; // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return SV{}; } /* q9 */; + // CHECK-FIXES: []() -> SV { return SV{}; } /* q9 */; []() -> SV { return (SV) nullptr; } /* q10 */; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return (SV) {}; } /* q10 */; + // CHECK-FIXES: []() -> SV { return (SV) {}; } /* q10 */; []() -> SV { return (SV){nullptr}; } /* q11 */; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: constructing{{.*}}default - // CHECK-FIXES: {{^}} []() -> SV { return (SV){}; } /* q11 */; + // CHECK-FIXES: []() -> SV { return (SV){}; } /* q11 */; []() -> SV { return static_cast<SV>(nullptr); } /* q12 */; // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: casting{{.*}}empty string - // CHECK-FIXES: {{^}} []() -> SV { return static_cast<SV>(""); } /* q12 */; + // CHECK-FIXES: []() -> SV { return static_cast<SV>(""); } /* q12 */; } } @@ -1600,13 +1600,13 @@ void constructor_invocation() /* r */ { explicit AcceptsSV(std::string_view) {} } r1(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} } r1(""); + // CHECK-FIXES: } r1(""); (void)(AcceptsSV{nullptr}) /* r2 */; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} (void)(AcceptsSV{""}) /* r2 */; + // CHECK-FIXES: (void)(AcceptsSV{""}) /* r2 */; AcceptsSV r3{nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: passing{{.*}}empty string - // CHECK-FIXES: {{^}} AcceptsSV r3{""}; + // CHECK-FIXES: AcceptsSV r3{""}; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-semicolon.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-semicolon.cpp index 4f9f4c5..8d87fe0 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-semicolon.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-semicolon.cpp @@ -35,7 +35,7 @@ void fail2() if(x == 5); nop(); // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: potentially unintended semicolon [bugprone-suspicious-semicolon] - // CHECK-FIXES: if(x == 5){{$}} + // CHECK-FIXES: if(x == 5) } void fail3() @@ -45,7 +45,7 @@ void fail3() nop(); } // CHECK-MESSAGES: :[[@LINE-4]]:11: warning: potentially unintended semicolon - // CHECK-FIXES: if(x < 5){{$}} + // CHECK-FIXES: if(x < 5) } void correct4() @@ -65,7 +65,7 @@ void fail4() for(int i = 0; i < x; ++i); nop(); // CHECK-MESSAGES: :[[@LINE-2]]:28: warning: potentially unintended semicolon - // CHECK-FIXES: for(int i = 0; i < x; ++i){{$}} + // CHECK-FIXES: for(int i = 0; i < x; ++i) } void fail5() @@ -73,7 +73,7 @@ void fail5() if(x % 5 == 1); nop(); // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: potentially unintended semicolon - // CHECK-FIXES: if(x % 5 == 1){{$}} + // CHECK-FIXES: if(x % 5 == 1) } void fail6() { @@ -82,7 +82,7 @@ void fail6() { } else if (a != 1); a = 2; // CHECK-MESSAGES: :[[@LINE-2]]:21: warning: potentially unintended semicolon - // CHECK-FIXES: } else if (a != 1){{$}} + // CHECK-FIXES: } else if (a != 1) } void fail7() { diff --git a/clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/init-variables.cpp b/clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/init-variables.cpp index 824431c..8a8973a 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/init-variables.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/init-variables.cpp @@ -1,5 +1,5 @@ // RUN: %check_clang_tidy %s cppcoreguidelines-init-variables -fix-errors %t -- -- -fno-delayed-template-parsing -fexceptions -// CHECK-FIXES: {{^}}#include <math.h> +// CHECK-FIXES: #include <math.h> // Ensure that function declarations are not changed. void some_func(int x, double d, bool b, const char *p); @@ -28,48 +28,48 @@ void template_test_function() { T t; int uninitialized; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: variable 'uninitialized' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} int uninitialized = 0;{{$}} + // CHECK-FIXES: int uninitialized = 0; } void init_unit_tests() { int x; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: variable 'x' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} int x = 0;{{$}} + // CHECK-FIXES: int x = 0; my_int_type myint; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: variable 'myint' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} my_int_type myint = 0;{{$}} + // CHECK-FIXES: my_int_type myint = 0; MACRO_INT macroint; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: variable 'macroint' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} MACRO_INT macroint = 0;{{$}} + // CHECK-FIXES: MACRO_INT macroint = 0; FULL_DECLARATION(); int x0 = 1, x1, x2 = 2; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: variable 'x1' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} int x0 = 1, x1 = 0, x2 = 2;{{$}} + // CHECK-FIXES: int x0 = 1, x1 = 0, x2 = 2; int y0, y1 = 1, y2; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: variable 'y0' is not initialized [cppcoreguidelines-init-variables] // CHECK-MESSAGES: :[[@LINE-2]]:19: warning: variable 'y2' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} int y0 = 0, y1 = 1, y2 = 0;{{$}} + // CHECK-FIXES: int y0 = 0, y1 = 1, y2 = 0; int hasval = 42; float f; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: variable 'f' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} float f = NAN;{{$}} + // CHECK-FIXES: float f = NAN; float fval = 85.0; double d; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: variable 'd' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} double d = NAN;{{$}} + // CHECK-FIXES: double d = NAN; double dval = 99.0; bool b; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: variable 'b' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} bool b = false;{{$}} + // CHECK-FIXES: bool b = false; bool bval = true; const char *ptr; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: variable 'ptr' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} const char *ptr = nullptr;{{$}} + // CHECK-FIXES: const char *ptr = nullptr; const char *ptrval = "a string"; UnusedStruct u; @@ -128,11 +128,11 @@ void uninitialized_enum() { void test_clang_diagnostic_error() { int a; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: variable 'a' is not initialized [cppcoreguidelines-init-variables] - // CHECK-FIXES: {{^}} int a = 0;{{$}} + // CHECK-FIXES: int a = 0; UnknownType b; // CHECK-MESSAGES: :[[@LINE-1]]:3: error: unknown type name 'UnknownType' [clang-diagnostic-error] - // CHECK-FIXES-NOT: {{^}} UnknownType b = 0;{{$}} + // CHECK-FIXES-NOT: UnknownType b = 0; } namespace gh112089 { @@ -148,3 +148,23 @@ namespace gh112089 { } } // namespace gh112089 +namespace gh161978 { + void test() { + bool (*fp1)(int); + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: variable 'fp1' is not initialized [cppcoreguidelines-init-variables] + // CHECK-FIXES: bool (*fp1)(int) = nullptr; + bool (*fp2)(int, int); + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: variable 'fp2' is not initialized [cppcoreguidelines-init-variables] + // CHECK-FIXES: bool (*fp2)(int, int) = nullptr; + bool (*fp3)(int, int, int); + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: variable 'fp3' is not initialized [cppcoreguidelines-init-variables] + // CHECK-FIXES: bool (*fp3)(int, int, int) = nullptr; + bool (*fp4)(int, int, int, ...); + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: variable 'fp4' is not initialized [cppcoreguidelines-init-variables] + // CHECK-FIXES: bool (*fp4)(int, int, int, ...) = nullptr; + bool (*fp5)(int, int), (*fp6)(int, int); + // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: variable 'fp5' is not initialized [cppcoreguidelines-init-variables] + // CHECK-MESSAGES: :[[@LINE-2]]:30: warning: variable 'fp6' is not initialized [cppcoreguidelines-init-variables] + // CHECK-FIXES: bool (*fp5)(int, int) = nullptr, (*fp6)(int, int) = nullptr; + } +} diff --git a/clang-tools-extra/test/clang-tidy/checkers/google/readability-namespace-comments.cpp b/clang-tools-extra/test/clang-tidy/checkers/google/readability-namespace-comments.cpp index 963449a..d555b87 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/google/readability-namespace-comments.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/google/readability-namespace-comments.cpp @@ -75,7 +75,7 @@ void h(); // CHECK-MESSAGES: :[[@LINE+2]]:1: warning: anonymous namespace not terminated with // CHECK-MESSAGES: :[[@LINE-10]]:26: note: anonymous namespace starts here } -// CHECK-FIXES: } // namespace{{$}} +// CHECK-FIXES: } // namespace namespace [[]] { void hh(); @@ -89,7 +89,7 @@ void hh(); // CHECK-MESSAGES: :[[@LINE+2]]:1: warning: anonymous namespace not terminated with // CHECK-MESSAGES: :[[@LINE-10]]:16: note: anonymous namespace starts here } -// CHECK-FIXES: } // namespace{{$}} +// CHECK-FIXES: } // namespace namespace short1 { namespace short2 { diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner-wrong-config.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner-wrong-config.cpp index 11ce59f..fdcb811 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner-wrong-config.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner-wrong-config.cpp @@ -7,4 +7,4 @@ // CHECK-MESSAGES: warning: The check 'misc-include-cleaner' will not perform any analysis because 'UnusedIncludes' and 'MissingIncludes' are both false. [clang-tidy-config] #include "bar.h" -// CHECK-FIXES-NOT: {{^}}#include "baz.h"{{$}} +// CHECK-FIXES-NOT: #include "baz.h" diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner.cpp index e10ac3f..3db0efa 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner.cpp @@ -1,10 +1,10 @@ // RUN: %check_clang_tidy %s misc-include-cleaner %t -- -- -I%S/Inputs -isystem%S/Inputs/system #include "bar.h" -// CHECK-FIXES: {{^}}#include "baz.h"{{$}} +// CHECK-FIXES: #include "baz.h" #include "foo.h" // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: included header foo.h is not used directly [misc-include-cleaner] // CHECK-FIXES: {{^}} -// CHECK-FIXES: {{^}}#include <string>{{$}} +// CHECK-FIXES: #include <string> #include <vector.h> // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: included header vector.h is not used directly [misc-include-cleaner] // CHECK-FIXES: {{^}} diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp index 95d8ecb..4ff0ba8 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/redundant-expression.cpp @@ -999,21 +999,21 @@ int TestOperatorConfusion(int X, int Y, long Z) int K = !(1 | 2 | 4); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: ineffective logical negation operator used; did you mean '~'? - // CHECK-FIXES: {{^}} int K = ~(1 | 2 | 4);{{$}} + // CHECK-FIXES: int K = ~(1 | 2 | 4); K = !(FLAG1 & FLAG2 & FLAG3); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: ineffective logical negation operator - // CHECK-FIXES: {{^}} K = ~(FLAG1 & FLAG2 & FLAG3);{{$}} + // CHECK-FIXES: K = ~(FLAG1 & FLAG2 & FLAG3); K = !(3 | 4); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: ineffective logical negation operator - // CHECK-FIXES: {{^}} K = ~(3 | 4);{{$}} + // CHECK-FIXES: K = ~(3 | 4); int NotFlags = !FLAGS; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: ineffective logical negation operator - // CHECK-FIXES: {{^}} int NotFlags = ~FLAGS;{{$}} + // CHECK-FIXES: int NotFlags = ~FLAGS; NotFlags = NOTFLAGS; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: ineffective logical negation operator return !(1 | 2 | 4); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: ineffective logical negation operator - // CHECK-FIXES: {{^}} return ~(1 | 2 | 4);{{$}} + // CHECK-FIXES: return ~(1 | 2 | 4); } template <int Shift, int Mask> diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters-strict.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters-strict.cpp index 319cefa..56d1306 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters-strict.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters-strict.cpp @@ -5,14 +5,14 @@ namespace strict_mode { void f(int foo) {} // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'foo' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void f(int /*foo*/) {}{{$}} +// CHECK-FIXES: void f(int /*foo*/) {} class E { int i; public: E(int j) {} // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'j' is unused -// CHECK-FIXES: {{^}} E(int /*j*/) {}{{$}} +// CHECK-FIXES: E(int /*j*/) {} }; class F { int i; @@ -20,7 +20,7 @@ class F { public: F(int j) : i() {} // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'j' is unused -// CHECK-FIXES: {{^}} F(int /*j*/) : i() {}{{$}} +// CHECK-FIXES: F(int /*j*/) : i() {} }; // Do not warn on naked functions. diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.c b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.c index e2f501c7..994dfa1 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.c +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.c @@ -4,14 +4,14 @@ // ============= void a(int i) {;} // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void a(int i) {;}{{$}} +// CHECK-FIXES: void a(int i) {;} #if __STDC_VERSION__ < 202311L static void b(); // In C before C23, forward declarations can leave out parameters. #endif static void b(int i) {;} // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}static void b() {;}{{$}} +// CHECK-FIXES: static void b() {;} // Unchanged cases // =============== diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.cpp index c963cb5..4baf839 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters.cpp @@ -11,36 +11,36 @@ // ============= void a(int i) {;} // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void a(int /*i*/) {;}{{$}} +// CHECK-FIXES: void a(int /*i*/) {;} void b(int i = 1) {;} // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void b(int /*i*/ = 1) {;}{{$}} +// CHECK-FIXES: void b(int /*i*/ = 1) {;} void c(int *i) {;} // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void c(int * /*i*/) {;}{{$}} +// CHECK-FIXES: void c(int * /*i*/) {;} void d(int i[]) {;} // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void d(int /*i*/[]) {;}{{$}} +// CHECK-FIXES: void d(int /*i*/[]) {;} void e(int i[1]) {;} // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void e(int /*i*/[1]) {;}{{$}} +// CHECK-FIXES: void e(int /*i*/[1]) {;} void f(void (*fn)()) {;} // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: parameter 'fn' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}void f(void (* /*fn*/)()) {;}{{$}} +// CHECK-FIXES: void f(void (* /*fn*/)()) {;} int *k([[clang::lifetimebound]] int *i) { return nullptr; } // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}int *k({{\[\[clang::lifetimebound\]\]}} int * /*i*/) { return nullptr; }{{$}} +// CHECK-FIXES: int *k({{\[\[clang::lifetimebound\]\]}} int * /*i*/) { return nullptr; } #define ATTR_BEFORE(x) [[clang::lifetimebound]] x int* m(ATTR_BEFORE(const int *i)) { return nullptr; } // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: parameter 'i' is unused [misc-unused-parameters] -// CHECK-FIXES: {{^}}int* m(ATTR_BEFORE(const int * /*i*/)) { return nullptr; }{{$}} +// CHECK-FIXES: int* m(ATTR_BEFORE(const int * /*i*/)) { return nullptr; } #undef ATTR_BEFORE // Unchanged cases @@ -64,44 +64,44 @@ static bool static_var = useLambda([] (int a) { return a; }); // Remove parameters of local functions // ==================================== static void staticFunctionA(int i); -// CHECK-FIXES: {{^}}static void staticFunctionA(); +// CHECK-FIXES: static void staticFunctionA(); static void staticFunctionA(int i) {;} // CHECK-MESSAGES: :[[@LINE-1]]:33: warning -// CHECK-FIXES: {{^}}static void staticFunctionA() +// CHECK-FIXES: static void staticFunctionA() static void staticFunctionB(int i, int j) { (void)i; } // CHECK-MESSAGES: :[[@LINE-1]]:40: warning -// CHECK-FIXES: {{^}}static void staticFunctionB(int i) +// CHECK-FIXES: static void staticFunctionB(int i) static void staticFunctionC(int i, int j) { (void)j; } // CHECK-MESSAGES: :[[@LINE-1]]:33: warning -// CHECK-FIXES: {{^}}static void staticFunctionC(int j) +// CHECK-FIXES: static void staticFunctionC(int j) static void staticFunctionD(int i, int j, int k) { (void)i; (void)k; } // CHECK-MESSAGES: :[[@LINE-1]]:40: warning -// CHECK-FIXES: {{^}}static void staticFunctionD(int i, int k) +// CHECK-FIXES: static void staticFunctionD(int i, int k) static void staticFunctionE(int i = 4) {;} // CHECK-MESSAGES: :[[@LINE-1]]:33: warning -// CHECK-FIXES: {{^}}static void staticFunctionE() +// CHECK-FIXES: static void staticFunctionE() static void staticFunctionF(int i = 4); -// CHECK-FIXES: {{^}}static void staticFunctionF(); +// CHECK-FIXES: static void staticFunctionF(); static void staticFunctionF(int i) {;} // CHECK-MESSAGES: :[[@LINE-1]]:33: warning -// CHECK-FIXES: {{^}}static void staticFunctionF() +// CHECK-FIXES: static void staticFunctionF() static void staticFunctionG(int i[]); -// CHECK-FIXES: {{^}}static void staticFunctionG(); +// CHECK-FIXES: static void staticFunctionG(); static void staticFunctionG(int i[]) {;} // CHECK-MESSAGES: :[[@LINE-1]]:33: warning -// CHECK-FIXES: {{^}}static void staticFunctionG() +// CHECK-FIXES: static void staticFunctionG() static void staticFunctionH(void (*fn)()); -// CHECK-FIXES: {{^}}static void staticFunctionH(); +// CHECK-FIXES: static void staticFunctionH(); static void staticFunctionH(void (*fn)()) {;} // CHECK-MESSAGES: :[[@LINE-1]]:36: warning -// CHECK-FIXES: {{^}}static void staticFunctionH() +// CHECK-FIXES: static void staticFunctionH() static void someCallSites() { staticFunctionA(1); @@ -136,12 +136,12 @@ static void someCallSites() { // ======================================================= static int variableWithLongName1(int LongName1, int LongName2) { // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: parameter 'LongName2' is unused -// CHECK-FIXES: {{^}}static int variableWithLongName1(int LongName1) { +// CHECK-FIXES: static int variableWithLongName1(int LongName1) { return LongName1; } static int variableWithLongName2(int LongName1, int LongName2) { // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: parameter 'LongName1' is unused -// CHECK-FIXES: {{^}}static int variableWithLongName2(int LongName2) { +// CHECK-FIXES: static int variableWithLongName2(int LongName2) { return LongName2; } static void someLongNameCallSites() { @@ -225,12 +225,12 @@ template <typename T> void someFunctionTemplate(T b, T e) { (void)b; (void)e; } template <typename T> void someFunctionTemplateOneUnusedParam(T b, T e) { (void)e; } // CHECK-MESSAGES: :[[@LINE-1]]:65: warning -// CHECK-FIXES: {{^}}template <typename T> void someFunctionTemplateOneUnusedParam(T /*b*/, T e) { (void)e; } +// CHECK-FIXES: template <typename T> void someFunctionTemplateOneUnusedParam(T /*b*/, T e) { (void)e; } template <typename T> void someFunctionTemplateAllUnusedParams(T b, T e) {;} // CHECK-MESSAGES: :[[@LINE-1]]:66: warning // CHECK-MESSAGES: :[[@LINE-2]]:71: warning -// CHECK-FIXES: {{^}}template <typename T> void someFunctionTemplateAllUnusedParams(T /*b*/, T /*e*/) {;} +// CHECK-FIXES: template <typename T> void someFunctionTemplateAllUnusedParams(T /*b*/, T /*e*/) {;} static void dontGetConfusedByParametersInFunctionTypes() { void (*F)(int i); } @@ -244,7 +244,7 @@ namespace { struct a { void b(int c) {;} // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: parameter 'c' is unused -// CHECK-FIXES: {{^}} void b() {;}{{$}} +// CHECK-FIXES: void b() {;} }; template <class> class d { @@ -262,7 +262,7 @@ void f2(int foo2) { } void f3(int foo3) {;} // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: parameter 'foo3' is unused -// CHECK-FIXES: {{^}}void f3(int /*foo3*/) {;}{{$}} +// CHECK-FIXES: void f3(int /*foo3*/) {;} class E { int i; @@ -277,7 +277,7 @@ public: // Constructor initializer counts as a non-empty body. F(int j) : i() {} // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'j' is unused -// CHECK-FIXES: {{^}} F(int /*j*/) : i() {}{{$}} +// CHECK-FIXES: F(int /*j*/) : i() {} }; class A { @@ -289,7 +289,7 @@ class B : public A { public: B(int i) : A() {} // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'i' is unused -// CHECK-FIXES: {{^}} B(int /*i*/) : A() {}{{$}} +// CHECK-FIXES: B(int /*i*/) : A() {} }; } // namespace strict_mode_off @@ -298,7 +298,7 @@ using fn = void(int); void f(fn *); void test() { // CHECK-MESSAGES: :[[@LINE+2]]:12: warning: parameter 'I' is unused - // CHECK-FIXES: {{^}} f([](int /*I*/) { + // CHECK-FIXES: f([](int /*I*/) { f([](int I) { return; }); } } // namespace lambda diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls-cxx17.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls-cxx17.cpp index 69e9cf7..ac11218e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls-cxx17.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls-cxx17.cpp @@ -22,7 +22,7 @@ using ns::Bar; using ns::Foo; using ns::Unused; // Unused // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: using decl 'Unused' is unused -// CHECK-FIXES: {{^}}// Unused +// CHECK-FIXES: // Unused void f() { Foo(123); diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx03.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx03.cpp index f01d6a6..b02dfd1 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx03.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx03.cpp @@ -2,69 +2,69 @@ #include <assert.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead [modernize-deprecated-headers] -// CHECK-FIXES: {{^}}#include <cassert>{{$}} +// CHECK-FIXES: #include <cassert> #include <complex.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead -// CHECK-FIXES: {{^}}#include <complex>{{$}} +// CHECK-FIXES: #include <complex> #include <ctype.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'ctype.h'; consider using 'cctype' instead -// CHECK-FIXES: {{^}}#include <cctype>{{$}} +// CHECK-FIXES: #include <cctype> #include <errno.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'errno.h'; consider using 'cerrno' instead -// CHECK-FIXES: {{^}}#include <cerrno>{{$}} +// CHECK-FIXES: #include <cerrno> #include <float.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'float.h'; consider using 'cfloat' instead -// CHECK-FIXES: {{^}}#include <cfloat>{{$}} +// CHECK-FIXES: #include <cfloat> #include <limits.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead -// CHECK-FIXES: {{^}}#include <climits>{{$}} +// CHECK-FIXES: #include <climits> #include <locale.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'locale.h'; consider using 'clocale' instead -// CHECK-FIXES: {{^}}#include <clocale>{{$}} +// CHECK-FIXES: #include <clocale> #include <math.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'math.h'; consider using 'cmath' instead -// CHECK-FIXES: {{^}}#include <cmath>{{$}} +// CHECK-FIXES: #include <cmath> #include <setjmp.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'setjmp.h'; consider using 'csetjmp' instead -// CHECK-FIXES: {{^}}#include <csetjmp>{{$}} +// CHECK-FIXES: #include <csetjmp> #include <signal.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'signal.h'; consider using 'csignal' instead -// CHECK-FIXES: {{^}}#include <csignal>{{$}} +// CHECK-FIXES: #include <csignal> #include <stdarg.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdarg.h'; consider using 'cstdarg' instead -// CHECK-FIXES: {{^}}#include <cstdarg>{{$}} +// CHECK-FIXES: #include <cstdarg> #include <stddef.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stddef.h'; consider using 'cstddef' instead -// CHECK-FIXES: {{^}}#include <cstddef>{{$}} +// CHECK-FIXES: #include <cstddef> #include <stdio.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead -// CHECK-FIXES: {{^}}#include <cstdio>{{$}} +// CHECK-FIXES: #include <cstdio> #include <stdlib.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead -// CHECK-FIXES: {{^}}#include <cstdlib>{{$}} +// CHECK-FIXES: #include <cstdlib> #include <string.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'string.h'; consider using 'cstring' instead -// CHECK-FIXES: {{^}}#include <cstring>{{$}} +// CHECK-FIXES: #include <cstring> #include <time.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'time.h'; consider using 'ctime' instead -// CHECK-FIXES: {{^}}#include <ctime>{{$}} +// CHECK-FIXES: #include <ctime> #include <wchar.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wchar.h'; consider using 'cwchar' instead -// CHECK-FIXES: {{^}}#include <cwchar>{{$}} +// CHECK-FIXES: #include <cwchar> #include <wctype.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wctype.h'; consider using 'cwctype' instead -// CHECK-FIXES: {{^}}#include <cwctype>{{$}} +// CHECK-FIXES: #include <cwctype> // Headers that have no effect in C++; remove them #include <stdalign.h> // <stdalign.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdalign.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// <stdalign.h>{{$}} +// CHECK-FIXES: // <stdalign.h> #include <stdbool.h> // <stdbool.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdbool.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// <stdbool.h>{{$}} +// CHECK-FIXES: // <stdbool.h> #include <iso646.h> // <iso646.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'iso646.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// <iso646.h>{{$}} +// CHECK-FIXES: // <iso646.h> // Headers deprecated since C++11: expect no diagnostics. #include <fenv.h> @@ -76,69 +76,69 @@ #include "assert.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead -// CHECK-FIXES: {{^}}#include <cassert>{{$}} +// CHECK-FIXES: #include <cassert> #include "complex.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead -// CHECK-FIXES: {{^}}#include <complex>{{$}} +// CHECK-FIXES: #include <complex> #include "ctype.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'ctype.h'; consider using 'cctype' instead -// CHECK-FIXES: {{^}}#include <cctype>{{$}} +// CHECK-FIXES: #include <cctype> #include "errno.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'errno.h'; consider using 'cerrno' instead -// CHECK-FIXES: {{^}}#include <cerrno>{{$}} +// CHECK-FIXES: #include <cerrno> #include "float.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'float.h'; consider using 'cfloat' instead -// CHECK-FIXES: {{^}}#include <cfloat>{{$}} +// CHECK-FIXES: #include <cfloat> #include "limits.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead -// CHECK-FIXES: {{^}}#include <climits>{{$}} +// CHECK-FIXES: #include <climits> #include "locale.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'locale.h'; consider using 'clocale' instead -// CHECK-FIXES: {{^}}#include <clocale>{{$}} +// CHECK-FIXES: #include <clocale> #include "math.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'math.h'; consider using 'cmath' instead -// CHECK-FIXES: {{^}}#include <cmath>{{$}} +// CHECK-FIXES: #include <cmath> #include "setjmp.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'setjmp.h'; consider using 'csetjmp' instead -// CHECK-FIXES: {{^}}#include <csetjmp>{{$}} +// CHECK-FIXES: #include <csetjmp> #include "signal.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'signal.h'; consider using 'csignal' instead -// CHECK-FIXES: {{^}}#include <csignal>{{$}} +// CHECK-FIXES: #include <csignal> #include "stdarg.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdarg.h'; consider using 'cstdarg' instead -// CHECK-FIXES: {{^}}#include <cstdarg>{{$}} +// CHECK-FIXES: #include <cstdarg> #include "stddef.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stddef.h'; consider using 'cstddef' instead -// CHECK-FIXES: {{^}}#include <cstddef>{{$}} +// CHECK-FIXES: #include <cstddef> #include "stdio.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead -// CHECK-FIXES: {{^}}#include <cstdio>{{$}} +// CHECK-FIXES: #include <cstdio> #include "stdlib.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead -// CHECK-FIXES: {{^}}#include <cstdlib>{{$}} +// CHECK-FIXES: #include <cstdlib> #include "string.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'string.h'; consider using 'cstring' instead -// CHECK-FIXES: {{^}}#include <cstring>{{$}} +// CHECK-FIXES: #include <cstring> #include "time.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'time.h'; consider using 'ctime' instead -// CHECK-FIXES: {{^}}#include <ctime>{{$}} +// CHECK-FIXES: #include <ctime> #include "wchar.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wchar.h'; consider using 'cwchar' instead -// CHECK-FIXES: {{^}}#include <cwchar>{{$}} +// CHECK-FIXES: #include <cwchar> #include "wctype.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wctype.h'; consider using 'cwctype' instead -// CHECK-FIXES: {{^}}#include <cwctype> +// CHECK-FIXES: #include <cwctype> // Headers that have no effect in C++; remove them #include "stdalign.h" // "stdalign.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdalign.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// "stdalign.h"{{$}} +// CHECK-FIXES: // "stdalign.h" #include "stdbool.h" // "stdbool.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdbool.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// "stdbool.h"{{$}} +// CHECK-FIXES: // "stdbool.h" #include "iso646.h" // "iso646.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'iso646.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// "iso646.h"{{$}} +// CHECK-FIXES: // "iso646.h" // Headers deprecated since C++11; expect no diagnostics #include "fenv.h" diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx11.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx11.cpp index 29c5dc4..99ef506 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx11.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-cxx11.cpp @@ -2,162 +2,162 @@ #include <assert.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead [modernize-deprecated-headers] -// CHECK-FIXES: {{^}}#include <cassert>{{$}} +// CHECK-FIXES: #include <cassert> #include <complex.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead -// CHECK-FIXES: {{^}}#include <complex>{{$}} +// CHECK-FIXES: #include <complex> #include <ctype.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'ctype.h'; consider using 'cctype' instead -// CHECK-FIXES: {{^}}#include <cctype>{{$}} +// CHECK-FIXES: #include <cctype> #include <errno.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'errno.h'; consider using 'cerrno' instead -// CHECK-FIXES: {{^}}#include <cerrno>{{$}} +// CHECK-FIXES: #include <cerrno> #include <fenv.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'fenv.h'; consider using 'cfenv' instead -// CHECK-FIXES: {{^}}#include <cfenv>{{$}} +// CHECK-FIXES: #include <cfenv> #include <float.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'float.h'; consider using 'cfloat' instead -// CHECK-FIXES: {{^}}#include <cfloat>{{$}} +// CHECK-FIXES: #include <cfloat> #include <inttypes.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'inttypes.h'; consider using 'cinttypes' instead -// CHECK-FIXES: {{^}}#include <cinttypes>{{$}} +// CHECK-FIXES: #include <cinttypes> #include <limits.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead -// CHECK-FIXES: {{^}}#include <climits>{{$}} +// CHECK-FIXES: #include <climits> #include <locale.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'locale.h'; consider using 'clocale' instead -// CHECK-FIXES: {{^}}#include <clocale>{{$}} +// CHECK-FIXES: #include <clocale> #include <math.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'math.h'; consider using 'cmath' instead -// CHECK-FIXES: {{^}}#include <cmath>{{$}} +// CHECK-FIXES: #include <cmath> #include <setjmp.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'setjmp.h'; consider using 'csetjmp' instead -// CHECK-FIXES: {{^}}#include <csetjmp>{{$}} +// CHECK-FIXES: #include <csetjmp> #include <signal.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'signal.h'; consider using 'csignal' instead -// CHECK-FIXES: {{^}}#include <csignal>{{$}} +// CHECK-FIXES: #include <csignal> #include <stdarg.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdarg.h'; consider using 'cstdarg' instead -// CHECK-FIXES: {{^}}#include <cstdarg>{{$}} +// CHECK-FIXES: #include <cstdarg> #include <stddef.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stddef.h'; consider using 'cstddef' instead -// CHECK-FIXES: {{^}}#include <cstddef>{{$}} +// CHECK-FIXES: #include <cstddef> #include <stdint.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdint.h'; consider using 'cstdint' instead -// CHECK-FIXES: {{^}}#include <cstdint>{{$}} +// CHECK-FIXES: #include <cstdint> #include <stdio.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead -// CHECK-FIXES: {{^}}#include <cstdio>{{$}} +// CHECK-FIXES: #include <cstdio> #include <stdlib.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead -// CHECK-FIXES: {{^}}#include <cstdlib>{{$}} +// CHECK-FIXES: #include <cstdlib> #include <string.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'string.h'; consider using 'cstring' instead -// CHECK-FIXES: {{^}}#include <cstring>{{$}} +// CHECK-FIXES: #include <cstring> #include <tgmath.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'tgmath.h'; consider using 'ctgmath' instead -// CHECK-FIXES: {{^}}#include <ctgmath>{{$}} +// CHECK-FIXES: #include <ctgmath> #include <time.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'time.h'; consider using 'ctime' instead -// CHECK-FIXES: {{^}}#include <ctime>{{$}} +// CHECK-FIXES: #include <ctime> #include <uchar.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'uchar.h'; consider using 'cuchar' instead -// CHECK-FIXES: {{^}}#include <cuchar>{{$}} +// CHECK-FIXES: #include <cuchar> #include <wchar.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wchar.h'; consider using 'cwchar' instead -// CHECK-FIXES: {{^}}#include <cwchar>{{$}} +// CHECK-FIXES: #include <cwchar> #include <wctype.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wctype.h'; consider using 'cwctype' instead -// CHECK-FIXES: {{^}}#include <cwctype> +// CHECK-FIXES: #include <cwctype> // Headers that have no effect in C++; remove them #include <stdalign.h> // <stdalign.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdalign.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// <stdalign.h>{{$}} +// CHECK-FIXES: // <stdalign.h> #include <stdbool.h> // <stdbool.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdbool.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// <stdbool.h>{{$}} +// CHECK-FIXES: // <stdbool.h> #include <iso646.h> // <iso646.h> // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'iso646.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// <iso646.h>{{$}} +// CHECK-FIXES: // <iso646.h> #include "assert.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead -// CHECK-FIXES: {{^}}#include <cassert>{{$}} +// CHECK-FIXES: #include <cassert> #include "complex.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead -// CHECK-FIXES: {{^}}#include <complex>{{$}} +// CHECK-FIXES: #include <complex> #include "ctype.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'ctype.h'; consider using 'cctype' instead -// CHECK-FIXES: {{^}}#include <cctype>{{$}} +// CHECK-FIXES: #include <cctype> #include "errno.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'errno.h'; consider using 'cerrno' instead -// CHECK-FIXES: {{^}}#include <cerrno>{{$}} +// CHECK-FIXES: #include <cerrno> #include "fenv.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'fenv.h'; consider using 'cfenv' instead -// CHECK-FIXES: {{^}}#include <cfenv>{{$}} +// CHECK-FIXES: #include <cfenv> #include "float.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'float.h'; consider using 'cfloat' instead -// CHECK-FIXES: {{^}}#include <cfloat>{{$}} +// CHECK-FIXES: #include <cfloat> #include "inttypes.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'inttypes.h'; consider using 'cinttypes' instead -// CHECK-FIXES: {{^}}#include <cinttypes>{{$}} +// CHECK-FIXES: #include <cinttypes> #include "limits.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead -// CHECK-FIXES: {{^}}#include <climits>{{$}} +// CHECK-FIXES: #include <climits> #include "locale.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'locale.h'; consider using 'clocale' instead -// CHECK-FIXES: {{^}}#include <clocale>{{$}} +// CHECK-FIXES: #include <clocale> #include "math.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'math.h'; consider using 'cmath' instead -// CHECK-FIXES: {{^}}#include <cmath>{{$}} +// CHECK-FIXES: #include <cmath> #include "setjmp.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'setjmp.h'; consider using 'csetjmp' instead -// CHECK-FIXES: {{^}}#include <csetjmp>{{$}} +// CHECK-FIXES: #include <csetjmp> #include "signal.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'signal.h'; consider using 'csignal' instead -// CHECK-FIXES: {{^}}#include <csignal>{{$}} +// CHECK-FIXES: #include <csignal> #include "stdarg.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdarg.h'; consider using 'cstdarg' instead -// CHECK-FIXES: {{^}}#include <cstdarg>{{$}} +// CHECK-FIXES: #include <cstdarg> #include "stddef.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stddef.h'; consider using 'cstddef' instead -// CHECK-FIXES: {{^}}#include <cstddef>{{$}} +// CHECK-FIXES: #include <cstddef> #include "stdint.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdint.h'; consider using 'cstdint' instead -// CHECK-FIXES: {{^}}#include <cstdint>{{$}} +// CHECK-FIXES: #include <cstdint> #include "stdio.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead -// CHECK-FIXES: {{^}}#include <cstdio>{{$}} +// CHECK-FIXES: #include <cstdio> #include "stdlib.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead -// CHECK-FIXES: {{^}}#include <cstdlib>{{$}} +// CHECK-FIXES: #include <cstdlib> #include "string.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'string.h'; consider using 'cstring' instead -// CHECK-FIXES: {{^}}#include <cstring>{{$}} +// CHECK-FIXES: #include <cstring> #include "tgmath.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'tgmath.h'; consider using 'ctgmath' instead -// CHECK-FIXES: {{^}}#include <ctgmath>{{$}} +// CHECK-FIXES: #include <ctgmath> #include "time.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'time.h'; consider using 'ctime' instead -// CHECK-FIXES: {{^}}#include <ctime>{{$}} +// CHECK-FIXES: #include <ctime> #include "uchar.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'uchar.h'; consider using 'cuchar' instead -// CHECK-FIXES: {{^}}#include <cuchar>{{$}} +// CHECK-FIXES: #include <cuchar> #include "wchar.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wchar.h'; consider using 'cwchar' instead -// CHECK-FIXES: {{^}}#include <cwchar>{{$}} +// CHECK-FIXES: #include <cwchar> #include "wctype.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'wctype.h'; consider using 'cwctype' instead -// CHECK-FIXES: {{^}}#include <cwctype> +// CHECK-FIXES: #include <cwctype> // Headers that have no effect in C++; remove them #include "stdalign.h" // "stdalign.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdalign.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// "stdalign.h"{{$}} +// CHECK-FIXES: // "stdalign.h" #include "stdbool.h" // "stdbool.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'stdbool.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// "stdbool.h"{{$}} +// CHECK-FIXES: // "stdbool.h" #include "iso646.h" // "iso646.h" // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: including 'iso646.h' has no effect in C++; consider removing it -// CHECK-FIXES: {{^}}// "iso646.h"{{$}} +// CHECK-FIXES: // "iso646.h" diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/raw-string-literal.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/raw-string-literal.cpp index 5856b88..3a98665 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/raw-string-literal.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/raw-string-literal.cpp @@ -2,7 +2,7 @@ char const *const BackSlash("goink\\frob"); // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal] -// CHECK-FIXES: {{^}}char const *const BackSlash(R"(goink\frob)");{{$}} +// CHECK-FIXES: char const *const BackSlash(R"(goink\frob)"); char const *const PlainLiteral("plain literal"); @@ -41,7 +41,7 @@ char const *const Us("goink\\\037"); char const *const HexNonPrintable("\\\x03"); char const *const Delete("\\\177"); char const *const MultibyteSnowman("\xE2\x98\x83"); -// CHECK-FIXES: {{^}}char const *const MultibyteSnowman("\xE2\x98\x83");{{$}} +// CHECK-FIXES: char const *const MultibyteSnowman("\xE2\x98\x83"); char const *const TrailingSpace("A line \\with space. \n"); char const *const TrailingNewLine("A single \\line.\n"); @@ -59,39 +59,39 @@ wchar_t const *const WideRawLiteral(LR"(foobie\\bletch)"); char const *const SingleQuote("goink\'frob"); // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: {{.*}} can be written as a raw string literal -// CHECK-XFIXES: {{^}}char const *const SingleQuote(R"(goink'frob)");{{$}} +// CHECK-XFIXES: char const *const SingleQuote(R"(goink'frob)"); char const *const DoubleQuote("goink\"frob"); // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const DoubleQuote(R"(goink"frob)");{{$}} +// CHECK-FIXES: char const *const DoubleQuote(R"(goink"frob)"); char const *const QuestionMark("goink\?frob"); // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const QuestionMark(R"(goink?frob)");{{$}} +// CHECK-FIXES: char const *const QuestionMark(R"(goink?frob)"); char const *const RegEx("goink\\(one|two\\)\\\\\\?.*\\nfrob"); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const RegEx(R"(goink\(one|two\)\\\?.*\nfrob)");{{$}} +// CHECK-FIXES: char const *const RegEx(R"(goink\(one|two\)\\\?.*\nfrob)"); char const *const Path("C:\\Program Files\\Vendor\\Application\\Application.exe"); // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const Path(R"(C:\Program Files\Vendor\Application\Application.exe)");{{$}} +// CHECK-FIXES: char const *const Path(R"(C:\Program Files\Vendor\Application\Application.exe)"); char const *const ContainsSentinel("who\\ops)\""); // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const ContainsSentinel(R"lit(who\ops)")lit");{{$}} +// CHECK-FIXES: char const *const ContainsSentinel(R"lit(who\ops)")lit"); char const *const ContainsDelim("whoops)\")lit\""); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const ContainsDelim(R"lit1(whoops)")lit")lit1");{{$}} +// CHECK-FIXES: char const *const ContainsDelim(R"lit1(whoops)")lit")lit1"); char const *const OctalPrintable("\100\\"); // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const OctalPrintable(R"(@\)");{{$}} +// CHECK-FIXES: char const *const OctalPrintable(R"(@\)"); char const *const HexPrintable("\x40\\"); // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}char const *const HexPrintable(R"(@\)");{{$}} +// CHECK-FIXES: char const *const HexPrintable(R"(@\)"); char const *const prettyFunction(__PRETTY_FUNCTION__); char const *const function(__FUNCTION__); @@ -111,23 +111,23 @@ template <typename T> void fn(char const *const Arg) { char const *const Str("foo\\bar"); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: {{.*}} can be written as a raw string literal - // CHECK-FIXES: {{^}} char const *const Str(R"(foo\bar)");{{$}} + // CHECK-FIXES: char const *const Str(R"(foo\bar)"); } template <> void fn<int>(char const *const Arg) { char const *const Str("foo\\bar"); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: {{.*}} can be written as a raw string literal - // CHECK-FIXES: {{^}} char const *const Str(R"(foo\bar)");{{$}} + // CHECK-FIXES: char const *const Str(R"(foo\bar)"); } void callFn() { fn<int>("foo\\bar"); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}} can be written as a raw string literal - // CHECK-FIXES: {{^}} fn<int>(R"(foo\bar)");{{$}} + // CHECK-FIXES: fn<int>(R"(foo\bar)"); fn<double>("foo\\bar"); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} can be written as a raw string literal - // CHECK-FIXES: {{^}} fn<double>(R"(foo\bar)");{{$}} + // CHECK-FIXES: fn<double>(R"(foo\bar)"); } namespace std { @@ -140,5 +140,5 @@ namespace gh97243 { using namespace std::ud; auto UserDefinedLiteral = "foo\\bar"_abc; // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: {{.*}} can be written as a raw string literal -// CHECK-FIXES: {{^}}auto UserDefinedLiteral = R"(foo\bar)"_abc; +// CHECK-FIXES: auto UserDefinedLiteral = R"(foo\bar)"_abc; } // namespace gh97243 diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg-delayed.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg-delayed.cpp index dd88775..4e05ada 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg-delayed.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg-delayed.cpp @@ -2,7 +2,7 @@ int foo(void) { // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant void argument list in function definition [modernize-redundant-void-arg] -// CHECK-FIXES: {{^}}int foo() {{{$}} +// CHECK-FIXES: int foo() { return 0; } @@ -10,7 +10,7 @@ template <class T> struct MyFoo { int foo(void) { // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant void argument list in function definition [modernize-redundant-void-arg] -// CHECK-FIXES: {{^}} int foo() {{{$}} +// CHECK-FIXES: int foo() { return 0; } }; @@ -22,7 +22,7 @@ struct MyBar { // This declaration isn't instantiated and won't be parsed 'delayed-template-parsing'. int foo(void) { // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant void argument list in function definition [modernize-redundant-void-arg] -// CHECK-FIXES: {{^}} int foo() {{{$}} +// CHECK-FIXES: int foo() { return 0; } }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg.cpp index f43a910..935163b 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/redundant-void-arg.cpp @@ -19,7 +19,7 @@ int j = 1; int foo(void) { // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant void argument list in function definition [modernize-redundant-void-arg] -// CHECK-FIXES: {{^}}int foo() {{{$}} +// CHECK-FIXES: int foo() { return 0; } @@ -32,23 +32,23 @@ typedef void my_void; int (*returns_fn_void_int(void))(void); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: {{.*}} in function declaration // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: {{.*}} in function declaration -// CHECK-FIXES: {{^}}int (*returns_fn_void_int())();{{$}} +// CHECK-FIXES: int (*returns_fn_void_int())(); typedef int (*returns_fn_void_int_t(void))(void); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: {{.*}} in typedef // CHECK-MESSAGES: :[[@LINE-2]]:44: warning: {{.*}} in typedef -// CHECK-FIXES: {{^}}typedef int (*returns_fn_void_int_t())();{{$}} +// CHECK-FIXES: typedef int (*returns_fn_void_int_t())(); // Should work for type aliases as well as typedef. using returns_fn_void_int_t2 = int (*(void))(void); // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: {{.*}} in type alias // CHECK-MESSAGES: :[[@LINE-2]]:46: warning: {{.*}} in type alias -// CHECK-FIXES: {{^}}using returns_fn_void_int_t2 = int (*())();{{$}} +// CHECK-FIXES: using returns_fn_void_int_t2 = int (*())(); int (*returns_fn_void_int(void))(void) { // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: {{.*}} in function definition // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}int (*returns_fn_void_int())() {{{$}} +// CHECK-FIXES: int (*returns_fn_void_int())() { return nullptr; } @@ -58,25 +58,25 @@ void (*(*returns_fn_returns_fn_void_void(void))(void))(void); // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: {{.*}} in function declaration // CHECK-MESSAGES: :[[@LINE-2]]:49: warning: {{.*}} in function declaration // CHECK-MESSAGES: :[[@LINE-3]]:56: warning: {{.*}} in function declaration -// CHECK-FIXES: {{^}}void (*(*returns_fn_returns_fn_void_void())())();{{$}} +// CHECK-FIXES: void (*(*returns_fn_returns_fn_void_void())())(); typedef void (*(*returns_fn_returns_fn_void_void_t(void))(void))(void); // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: {{.*}} in typedef // CHECK-MESSAGES: :[[@LINE-2]]:59: warning: {{.*}} in typedef // CHECK-MESSAGES: :[[@LINE-3]]:66: warning: {{.*}} in typedef -// CHECK-FIXES: {{^}}typedef void (*(*returns_fn_returns_fn_void_void_t())())();{{$}} +// CHECK-FIXES: typedef void (*(*returns_fn_returns_fn_void_void_t())())(); void (*(*returns_fn_returns_fn_void_void(void))(void))(void) { // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: {{.*}} in function definition // CHECK-MESSAGES: :[[@LINE-2]]:49: warning: {{.*}} in function definition // CHECK-MESSAGES: :[[@LINE-3]]:56: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}void (*(*returns_fn_returns_fn_void_void())())() {{{$}} +// CHECK-FIXES: void (*(*returns_fn_returns_fn_void_void())())() { return nullptr; } void bar(void) { // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}void bar() {{{$}} +// CHECK-FIXES: void bar() { } void op_fn(int i) { @@ -103,13 +103,13 @@ private: void (*f1)(void); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: {{.*}} in field declaration - // CHECK-FIXES: {{^ }}void (*f1)();{{$}} + // CHECK-FIXES: void (*f1)(); void (*op)(int i); void (gronk::*p1)(void); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in field declaration - // CHECK-FIXES: {{^ }}void (gronk::*p1)();{{$}} + // CHECK-FIXES: void (gronk::*p1)(); int (gronk::*p_mi); @@ -119,13 +119,13 @@ private: // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: {{.*}} in function declaration // CHECK-MESSAGES: :[[@LINE-2]]:51: warning: {{.*}} in function declaration // CHECK-MESSAGES: :[[@LINE-3]]:58: warning: {{.*}} in function declaration - // CHECK-FIXES: {{^}} void (*(*returns_fn_returns_fn_void_void())())();{{$}} + // CHECK-FIXES: void (*(*returns_fn_returns_fn_void_void())())(); void (*(*(gronk::*returns_fn_returns_fn_void_void_mem)(void))(void))(void); // CHECK-MESSAGES: :[[@LINE-1]]:58: warning: {{.*}} in field declaration // CHECK-MESSAGES: :[[@LINE-2]]:65: warning: {{.*}} in field declaration // CHECK-MESSAGES: :[[@LINE-3]]:72: warning: {{.*}} in field declaration - // CHECK-FIXES: {{^}} void (*(*(gronk::*returns_fn_returns_fn_void_void_mem)())())();{{$}} + // CHECK-FIXES: void (*(*(gronk::*returns_fn_returns_fn_void_void_mem)())())(); }; int i; @@ -138,35 +138,35 @@ double *pd; void (*f1)(void); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}} in variable declaration -// CHECK-FIXES: {{^}}void (*f1)();{{$}} +// CHECK-FIXES: void (*f1)(); void (*f2)(void) = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f2)() = nullptr;{{$}} +// CHECK-FIXES: void (*f2)() = nullptr; void (*f2b)(void)(nullptr); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f2b)()(nullptr);{{$}} +// CHECK-FIXES: void (*f2b)()(nullptr); void (*f2c)(void){nullptr}; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f2c)(){nullptr};{{$}} +// CHECK-FIXES: void (*f2c)(){nullptr}; void (*f2d)(void) = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f2d)() = NULL;{{$}} +// CHECK-FIXES: void (*f2d)() = NULL; void (*f2e)(void)(NULL); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f2e)()(NULL);{{$}} +// CHECK-FIXES: void (*f2e)()(NULL); void (*f2f)(void){NULL}; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f2f)(){NULL};{{$}} +// CHECK-FIXES: void (*f2f)(){NULL}; void (*f3)(void) = bar; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (*f3)() = bar;{{$}} +// CHECK-FIXES: void (*f3)() = bar; void (*o1)(int i); void (*o2)(int i) = nullptr; @@ -185,7 +185,7 @@ void (*fc)() = bar; typedef void (function_ptr)(void); // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: {{.*}} in typedef -// CHECK-FIXES: {{^}}typedef void (function_ptr)();{{$}} +// CHECK-FIXES: typedef void (function_ptr)(); // intentionally not LLVM style to check preservation of whitespace typedef void (function_ptr2) @@ -245,15 +245,15 @@ void void (gronk::*p1)(void); // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: {{.*}} in variable declaration -// CHECK-FIXES: {{^}}void (gronk::*p1)();{{$}} +// CHECK-FIXES: void (gronk::*p1)(); void (gronk::*p2)(void) = &gronk::foo; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: {{.*}} in variable declaration with initializer -// CHECK-FIXES: {{^}}void (gronk::*p2)() = &gronk::foo;{{$}} +// CHECK-FIXES: void (gronk::*p2)() = &gronk::foo; typedef void (gronk::*member_function_ptr)(void); // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: {{.*}} in typedef -// CHECK-FIXES: {{^}}typedef void (gronk::*member_function_ptr)();{{$}} +// CHECK-FIXES: typedef void (gronk::*member_function_ptr)(); // intentionally not LLVM style to check preservation of whitespace typedef void (gronk::*member_function_ptr2) @@ -269,11 +269,11 @@ typedef void (gronk::*member_function_ptr2) void gronk::foo() { void (*f1)(void) = &::bar; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration with initializer - // CHECK-FIXES: {{^ }}void (*f1)() = &::bar;{{$}} + // CHECK-FIXES: void (*f1)() = &::bar; void (*f2)(void); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration - // CHECK-FIXES: {{^ }}void (*f2)();{{$}} + // CHECK-FIXES: void (*f2)(); // intentionally not LLVM style to check preservation of whitespace void (*f3) @@ -289,14 +289,14 @@ void gronk::foo() { void gronk::bar(void) { // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}void gronk::bar() {{{$}} +// CHECK-FIXES: void gronk::bar() { void (gronk::*p3)(void) = &gronk::foo; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in variable declaration with initializer - // CHECK-FIXES: {{^ }}void (gronk::*p3)() = &gronk::foo;{{$}} + // CHECK-FIXES: void (gronk::*p3)() = &gronk::foo; void (gronk::*p4)(void); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in variable declaration - // CHECK-FIXES: {{^ }}void (gronk::*p4)();{{$}} + // CHECK-FIXES: void (gronk::*p4)(); // intentionally not LLVM style to check preservation of whitespace void (gronk::*p5) @@ -325,14 +325,14 @@ void gronk::bar2 gronk::gronk(void) // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}gronk::gronk(){{$}} +// CHECK-FIXES: gronk::gronk() : f1(nullptr), p1(nullptr) { } gronk::~gronk(void) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}gronk::~gronk() {{{$}} +// CHECK-FIXES: gronk::~gronk() { } class nutter { @@ -342,21 +342,21 @@ public: nutter::nutter(void) { // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: {{.*}} in function definition -// CHECK-FIXES: {{^}}nutter::nutter() {{{$}} +// CHECK-FIXES: nutter::nutter() { void (*f3)(void) = static_cast<void (*)(void)>(0); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration with initializer // CHECK-MESSAGES: :[[@LINE-2]]:43: warning: {{.*}} in named cast - // CHECK-FIXES: void (*f3)() = static_cast<void (*)()>(0);{{$}} + // CHECK-FIXES: void (*f3)() = static_cast<void (*)()>(0); void (*f4)(void) = (void (*)(void)) 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration with initializer // CHECK-MESSAGES: :[[@LINE-2]]:32: warning: {{.*}} in cast expression - // CHECK-FIXES: void (*f4)() = (void (*)()) 0;{{$}} + // CHECK-FIXES: void (*f4)() = (void (*)()) 0; void (*f5)(void) = reinterpret_cast<void (*)(void)>(0); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration with initializer // CHECK-MESSAGES: :[[@LINE-2]]:48: warning: {{.*}} in named cast - // CHECK-FIXES: void (*f5)() = reinterpret_cast<void (*)()>(0);{{$}} + // CHECK-FIXES: void (*f5)() = reinterpret_cast<void (*)()>(0); // intentionally not LLVM style to check preservation of whitespace void (*f6)(void) = static_cast<void (*) @@ -403,17 +403,17 @@ class generator { public: int operator()(void) { return 1; } // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: {{.*}} in function definition - // CHECK-FIXES: {{^ }}int operator()() { return 1; }{{$}} + // CHECK-FIXES: int operator()() { return 1; } }; void test_lambda_functions() { auto lamb_duh = [](void (*fn)(void)) { (*fn)(); }; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: {{.*}} in variable declaration - // CHECK-FIXES: {{^ }}auto lamb_duh = [](void (*fn)()) { (*fn)(); };{{$}} + // CHECK-FIXES: auto lamb_duh = [](void (*fn)()) { (*fn)(); }; auto lambda_generator = [](void) { return 1; }; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: {{.*}} in lambda expression - // CHECK-FIXES: {{^ }}auto lambda_generator = []() { return 1; };{{$}} + // CHECK-FIXES: auto lambda_generator = []() { return 1; }; auto gen2 = []() { return 1; }; @@ -422,7 +422,7 @@ void test_lambda_functions() { auto void_returner = [](void) -> void (*)(void) { return f1; }; // CHECK-MESSAGES: [[@LINE-1]]:27: warning: {{.*}} in lambda expression // CHECK-MESSAGES: [[@LINE-2]]:45: warning: {{.*}} in lambda expression - // CHECK-FIXES: {{^ }}auto void_returner = []() -> void (*)() { return f1; };{{$}} + // CHECK-FIXES: auto void_returner = []() -> void (*)() { return f1; }; } #define M(x) x diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/replace-disallow-copy-and-assign-macro.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/replace-disallow-copy-and-assign-macro.cpp index 45893c6a..efd6fc9 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/replace-disallow-copy-and-assign-macro.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/replace-disallow-copy-and-assign-macro.cpp @@ -33,8 +33,8 @@ private: DISALLOW_COPY_AND_ASSIGN(TestClass1); }; // CHECK-MESSAGES-DEFAULT: :[[@LINE-2]]:3: warning: prefer deleting copy constructor and assignment operator over using macro 'DISALLOW_COPY_AND_ASSIGN' [modernize-replace-disallow-copy-and-assign-macro] -// CHECK-FIXES-DEFAULT: {{^}} TestClass1(const TestClass1 &) = delete;{{$}} -// CHECK-FIXES-DEFAULT-NEXT: {{^}} const TestClass1 &operator=(const TestClass1 &) = delete;{{$}} +// CHECK-FIXES-DEFAULT: TestClass1(const TestClass1 &) = delete; +// CHECK-FIXES-DEFAULT-NEXT: const TestClass1 &operator=(const TestClass1 &) = delete; #define MY_MACRO_NAME(TypeName) @@ -43,8 +43,8 @@ private: MY_MACRO_NAME(TestClass2); }; // CHECK-MESSAGES-DIFFERENT-NAME: :[[@LINE-2]]:3: warning: prefer deleting copy constructor and assignment operator over using macro 'MY_MACRO_NAME' [modernize-replace-disallow-copy-and-assign-macro] -// CHECK-FIXES-DIFFERENT-NAME: {{^}} TestClass2(const TestClass2 &) = delete;{{$}} -// CHECK-FIXES-DIFFERENT-NAME-NEXT: {{^}} const TestClass2 &operator=(const TestClass2 &) = delete;{{$}} +// CHECK-FIXES-DIFFERENT-NAME: TestClass2(const TestClass2 &) = delete; +// CHECK-FIXES-DIFFERENT-NAME-NEXT: const TestClass2 &operator=(const TestClass2 &) = delete; #define DISALLOW_COPY_AND_ASSIGN_FINALIZE(TypeName) \ TypeName(const TypeName &) = delete; \ @@ -58,8 +58,8 @@ private: DISALLOW_COPY_AND_ASSIGN_FINALIZE(TestClass3) }; // CHECK-MESSAGES-FINALIZE: :[[@LINE-2]]:3: warning: prefer deleting copy constructor and assignment operator over using macro 'DISALLOW_COPY_AND_ASSIGN_FINALIZE' [modernize-replace-disallow-copy-and-assign-macro] -// CHECK-FIXES-FINALIZE: {{^}} TestClass3(const TestClass3 &) = delete;{{$}} -// CHECK-FIXES-FINALIZE-NEXT: {{^}} const TestClass3 &operator=(const TestClass3 &) = delete;{{$}} +// CHECK-FIXES-FINALIZE: TestClass3(const TestClass3 &) = delete; +// CHECK-FIXES-FINALIZE-NEXT: const TestClass3 &operator=(const TestClass3 &) = delete; #define DISALLOW_COPY_AND_ASSIGN_MORE_AGUMENTS(A, B) diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-bool-literals.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-bool-literals.cpp index 30c10ef..1acb3c3 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-bool-literals.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-bool-literals.cpp @@ -5,43 +5,43 @@ bool IntToTrue = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals] -// CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}} +// CHECK-FIXES: bool IntToTrue = true; bool IntToFalse(0); // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}} +// CHECK-FIXES: bool IntToFalse(false); bool LongLongToTrue{0x1LL}; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool LongLongToTrue{true};{{$}} +// CHECK-FIXES: bool LongLongToTrue{true}; bool ExplicitCStyleIntToFalse = (bool)0; // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool ExplicitCStyleIntToFalse = false;{{$}} +// CHECK-FIXES: bool ExplicitCStyleIntToFalse = false; bool ExplicitFunctionalIntToFalse = bool(0); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool ExplicitFunctionalIntToFalse = false;{{$}} +// CHECK-FIXES: bool ExplicitFunctionalIntToFalse = false; bool ExplicitStaticIntToFalse = static_cast<bool>(0); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool ExplicitStaticIntToFalse = false;{{$}} +// CHECK-FIXES: bool ExplicitStaticIntToFalse = false; #define TRUE_MACRO 1 -// CHECK-FIXES: {{^}}#define TRUE_MACRO 1{{$}} +// CHECK-FIXES: #define TRUE_MACRO 1 bool MacroIntToTrue = TRUE_MACRO; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool MacroIntToTrue = TRUE_MACRO;{{$}} +// CHECK-FIXES: bool MacroIntToTrue = TRUE_MACRO; #define FALSE_MACRO bool(0) -// CHECK-FIXES: {{^}}#define FALSE_MACRO bool(0){{$}} +// CHECK-FIXES: #define FALSE_MACRO bool(0) bool TrueBool = true; // OK bool FalseBool = bool(FALSE_MACRO); // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool FalseBool = bool(FALSE_MACRO);{{$}} +// CHECK-FIXES: bool FalseBool = bool(FALSE_MACRO); void boolFunction(bool bar) { @@ -52,58 +52,58 @@ char Character = 0; // OK unsigned long long LongInteger = 1; // OK #define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x) -// CHECK-FIXES: {{^}}#define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x){{$}} +// CHECK-FIXES: #define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x) bool MacroDependentBool = MACRO_DEPENDENT_CAST(0); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool MacroDependentBool = MACRO_DEPENDENT_CAST(0);{{$}} +// CHECK-FIXES: bool MacroDependentBool = MACRO_DEPENDENT_CAST(0); bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO); // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: converting integer literal to bool -// CHECK-FIXES: {{^}}bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO);{{$}} +// CHECK-FIXES: bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO); class FooClass { public: FooClass() : JustBool(0) {} // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}FooClass() : JustBool(false) {}{{$}} + // CHECK-FIXES: FooClass() : JustBool(false) {} FooClass(int) : JustBool{0} {} // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}FooClass(int) : JustBool{false} {}{{$}} + // CHECK-FIXES: FooClass(int) : JustBool{false} {} private: bool JustBool; bool BoolWithBraces{0}; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}bool BoolWithBraces{false};{{$}} + // CHECK-FIXES: bool BoolWithBraces{false}; bool BoolFromInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}bool BoolFromInt = false;{{$}} + // CHECK-FIXES: bool BoolFromInt = false; bool SimpleBool = true; // OK }; template<typename type> void templateFunction(type) { type TemplateType = 0; - // CHECK-FIXES: {{^ *}}type TemplateType = 0;{{$}} + // CHECK-FIXES: type TemplateType = 0; } template<int c> void valueDependentTemplateFunction() { bool Boolean = c; - // CHECK-FIXES: {{^ *}}bool Boolean = c;{{$}} + // CHECK-FIXES: bool Boolean = c; } template<typename type> void anotherTemplateFunction(type) { bool JustBool = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}bool JustBool = false;{{$}} + // CHECK-FIXES: bool JustBool = false; } int main() { boolFunction(1); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}boolFunction(true);{{$}} + // CHECK-FIXES: boolFunction(true); boolFunction(false); @@ -117,7 +117,7 @@ int main() { IntToTrue = 1; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}IntToTrue = true;{{$}} + // CHECK-FIXES: IntToTrue = true; } static int Value = 1; @@ -126,7 +126,7 @@ bool Function1() { bool Result = Value == 1 ? 1 : 0; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: converting integer literal to bool // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}bool Result = Value == 1 ? true : false;{{$}} + // CHECK-FIXES: bool Result = Value == 1 ? true : false; return Result; } @@ -134,18 +134,18 @@ bool Function2() { return Value == 1 ? 1 : 0; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}return Value == 1 ? true : false;{{$}} + // CHECK-FIXES: return Value == 1 ? true : false; } void foo() { bool Result; Result = Value == 1 ? true : 0; // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}Result = Value == 1 ? true : false;{{$}} + // CHECK-FIXES: Result = Value == 1 ? true : false; Result = Value == 1 ? false : bool(0); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}Result = Value == 1 ? false : false;{{$}} + // CHECK-FIXES: Result = Value == 1 ? false : false; Result = Value == 1 ? (bool)0 : false; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: converting integer literal to bool - // CHECK-FIXES: {{^ *}}Result = Value == 1 ? false : false;{{$}} + // CHECK-FIXES: Result = Value == 1 ? false : false; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints-first-greatergreater.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints-first-greatergreater.cpp index c3b2c18..b92e909 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints-first-greatergreater.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints-first-greatergreater.cpp @@ -19,4 +19,4 @@ template <typename T, typename = std::enable_if_t<T::some_value>> void first_greatergreater_is_enable_if() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void first_greatergreater_is_enable_if() requires T::some_value {{{$}} +// CHECK-FIXES: void first_greatergreater_is_enable_if() requires T::some_value { diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints.cpp index 90131c3..ecae361 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-constraints.cpp @@ -33,28 +33,28 @@ typename std::enable_if<T::some_value, Obj>::type basic() { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj basic() requires T::some_value {{{$}} +// CHECK-FIXES: Obj basic() requires T::some_value { template <typename T> std::enable_if_t<T::some_value, Obj> basic_t() { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj basic_t() requires T::some_value {{{$}} +// CHECK-FIXES: Obj basic_t() requires T::some_value { template <typename T> auto basic_trailing() -> typename std::enable_if<T::some_value, Obj>::type { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:26: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}auto basic_trailing() -> Obj requires T::some_value {{{$}} +// CHECK-FIXES: auto basic_trailing() -> Obj requires T::some_value { template <typename T> typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) {{{$}} +// CHECK-FIXES: typename std::enable_if<T::some_value, Obj>::type existing_constraint() requires (T::another_value) { template <typename U> typename std::enable_if<U::some_value, Obj>::type decl_without_def(); @@ -79,32 +79,32 @@ typename std::enable_if<T::some_value, int>::type* pointer_of_enable_if() { return nullptr; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: int* pointer_of_enable_if() requires T::some_value { template <typename T> std::enable_if_t<T::some_value, int>* pointer_of_enable_if_t() { return nullptr; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if_t() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: int* pointer_of_enable_if_t() requires T::some_value { template <typename T> const std::enable_if_t<T::some_value, int>* const_pointer_of_enable_if_t() { return nullptr; } // CHECK-MESSAGES: :[[@LINE-3]]:7: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}const int* const_pointer_of_enable_if_t() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: const int* const_pointer_of_enable_if_t() requires T::some_value { template <typename T> std::enable_if_t<T::some_value, int> const * const_pointer_of_enable_if_t2() { return nullptr; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}int const * const_pointer_of_enable_if_t2() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: int const * const_pointer_of_enable_if_t2() requires T::some_value { template <typename T> @@ -112,34 +112,34 @@ std::enable_if_t<T::some_value, int>& reference_of_enable_if_t() { static int x; return x; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}int& reference_of_enable_if_t() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: int& reference_of_enable_if_t() requires T::some_value { template <typename T> const std::enable_if_t<T::some_value, int>& const_reference_of_enable_if_t() { static int x; return x; } // CHECK-MESSAGES: :[[@LINE-3]]:7: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}const int& const_reference_of_enable_if_t() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: const int& const_reference_of_enable_if_t() requires T::some_value { template <typename T> typename std::enable_if<T::some_value>::type enable_if_default_void() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void enable_if_default_void() requires T::some_value {{{$}} +// CHECK-FIXES: void enable_if_default_void() requires T::some_value { template <typename T> std::enable_if_t<T::some_value> enable_if_t_default_void() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void enable_if_t_default_void() requires T::some_value {{{$}} +// CHECK-FIXES: void enable_if_t_default_void() requires T::some_value { template <typename T> std::enable_if_t<T::some_value>* enable_if_t_default_void_pointer() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void* enable_if_t_default_void_pointer() requires T::some_value {{{$}} +// CHECK-FIXES: void* enable_if_t_default_void_pointer() requires T::some_value { namespace using_namespace_std { @@ -149,25 +149,25 @@ template <typename T> typename enable_if<T::some_value>::type with_typename() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void with_typename() requires T::some_value {{{$}} +// CHECK-FIXES: void with_typename() requires T::some_value { template <typename T> enable_if_t<T::some_value> with_t() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void with_t() requires T::some_value {{{$}} +// CHECK-FIXES: void with_t() requires T::some_value { template <typename T> typename enable_if<T::some_value, int>::type with_typename_and_type() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}int with_typename_and_type() requires T::some_value {{{$}} +// CHECK-FIXES: int with_typename_and_type() requires T::some_value { template <typename T> enable_if_t<T::some_value, int> with_t_and_type() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}int with_t_and_type() requires T::some_value {{{$}} +// CHECK-FIXES: int with_t_and_type() requires T::some_value { } // namespace using_namespace_std @@ -213,43 +213,43 @@ template <typename T> std::enable_if_t<Traits<T>::value> type_trait_value() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void type_trait_value() requires Traits<T>::value {{{$}} +// CHECK-FIXES: void type_trait_value() requires Traits<T>::value { template <typename T> std::enable_if_t<Traits<T>::member()> type_trait_member_call() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void type_trait_member_call() requires (Traits<T>::member()) {{{$}} +// CHECK-FIXES: void type_trait_member_call() requires (Traits<T>::member()) { template <typename T> std::enable_if_t<!Traits<T>::value> negate() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void negate() requires (!Traits<T>::value) {{{$}} +// CHECK-FIXES: void negate() requires (!Traits<T>::value) { template <typename T> std::enable_if_t<Traits<T>::value1 && Traits<T>::value2> conjunction() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void conjunction() requires (Traits<T>::value1 && Traits<T>::value2) {{{$}} +// CHECK-FIXES: void conjunction() requires (Traits<T>::value1 && Traits<T>::value2) { template <typename T> std::enable_if_t<Traits<T>::value1 || Traits<T>::value2> disjunction() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void disjunction() requires (Traits<T>::value1 || Traits<T>::value2) {{{$}} +// CHECK-FIXES: void disjunction() requires (Traits<T>::value1 || Traits<T>::value2) { template <typename T> std::enable_if_t<Traits<T>::value1 && !Traits<T>::value2> conjunction_with_negate() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void conjunction_with_negate() requires (Traits<T>::value1 && !Traits<T>::value2) {{{$}} +// CHECK-FIXES: void conjunction_with_negate() requires (Traits<T>::value1 && !Traits<T>::value2) { template <typename T> std::enable_if_t<Traits<T>::value1 == (Traits<T>::value2 + 5)> complex_operators() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void complex_operators() requires (Traits<T>::value1 == (Traits<T>::value2 + 5)) {{{$}} +// CHECK-FIXES: void complex_operators() requires (Traits<T>::value1 == (Traits<T>::value2 + 5)) { } // namespace primary_expression_tests @@ -263,14 +263,14 @@ constexpr typename std::enable_if<T::some_value, int>::type constexpr_decl() { return 10; } // CHECK-MESSAGES: :[[@LINE-3]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}constexpr int constexpr_decl() requires T::some_value {{{$}} +// CHECK-FIXES: constexpr int constexpr_decl() requires T::some_value { template <typename T> static inline constexpr typename std::enable_if<T::some_value, int>::type static_inline_constexpr_decl() { return 10; } // CHECK-MESSAGES: :[[@LINE-3]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}static inline constexpr int static_inline_constexpr_decl() requires T::some_value {{{$}} +// CHECK-FIXES: static inline constexpr int static_inline_constexpr_decl() requires T::some_value { template <typename T> static @@ -279,16 +279,16 @@ static_decl() { return 10; } // CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}static{{$}} -// CHECK-FIXES-NEXT: {{^}}int{{$}} -// CHECK-FIXES-NEXT: {{^}}static_decl() requires T::some_value {{{$}} +// CHECK-FIXES: static +// CHECK-FIXES-NEXT: int +// CHECK-FIXES-NEXT: static_decl() requires T::some_value { template <typename T> constexpr /* comment */ typename std::enable_if<T::some_value, int>::type constexpr_comment_decl() { return 10; } // CHECK-MESSAGES: :[[@LINE-3]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}constexpr /* comment */ int constexpr_comment_decl() requires T::some_value {{{$}} +// CHECK-FIXES: constexpr /* comment */ int constexpr_comment_decl() requires T::some_value { //////////////////////////////// @@ -302,45 +302,45 @@ struct AClass { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:10: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} static Obj static_method() requires T::some_value {{{$}} + // CHECK-FIXES: static Obj static_method() requires T::some_value { template <typename T> typename std::enable_if<T::some_value, Obj>::type member() { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} Obj member() requires T::some_value {{{$}} + // CHECK-FIXES: Obj member() requires T::some_value { template <typename T> typename std::enable_if<T::some_value, Obj>::type const_qualifier() const { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} Obj const_qualifier() const requires T::some_value {{{$}} + // CHECK-FIXES: Obj const_qualifier() const requires T::some_value { template <typename T> typename std::enable_if<T::some_value, Obj>::type rvalue_ref_qualifier() && { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} Obj rvalue_ref_qualifier() && requires T::some_value {{{$}} + // CHECK-FIXES: Obj rvalue_ref_qualifier() && requires T::some_value { template <typename T> typename std::enable_if<T::some_value, Obj>::type rvalue_ref_qualifier_comment() /* c1 */ && /* c2 */ { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} Obj rvalue_ref_qualifier_comment() /* c1 */ && /* c2 */ requires T::some_value {{{$}} + // CHECK-FIXES: Obj rvalue_ref_qualifier_comment() /* c1 */ && /* c2 */ requires T::some_value { template <typename T> std::enable_if_t<T::some_value, AClass&> operator=(T&&) = delete; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} AClass& operator=(T&&) requires T::some_value = delete; + // CHECK-FIXES: AClass& operator=(T&&) requires T::some_value = delete; template<typename T> std::enable_if_t<T::some_value, AClass&> operator=(ConsumeVariadic<T>) noexcept(requires (T t) { t = 4; }) = delete; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} AClass& operator=(ConsumeVariadic<T>) noexcept(requires (T t) { t = 4; }) requires T::some_value = delete; + // CHECK-FIXES: AClass& operator=(ConsumeVariadic<T>) noexcept(requires (T t) { t = 4; }) requires T::some_value = delete; }; @@ -354,7 +354,7 @@ typename std::enable_if</* check1 */ T::some_value, Obj>::type leading_comment() return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj leading_comment() requires /* check1 */ T::some_value {{{$}} +// CHECK-FIXES: Obj leading_comment() requires /* check1 */ T::some_value { template <typename T> typename std::enable_if<T::some_value, Obj>::type body_on_next_line() @@ -362,22 +362,22 @@ typename std::enable_if<T::some_value, Obj>::type body_on_next_line() return Obj{}; } // CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj body_on_next_line(){{$}} -// CHECK-FIXES-NEXT: {{^}}requires T::some_value {{{$}} +// CHECK-FIXES: Obj body_on_next_line() +// CHECK-FIXES-NEXT: requires T::some_value { template <typename T> typename std::enable_if< /* check1 */ T::some_value, Obj>::type leading_comment_whitespace() { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj leading_comment_whitespace() requires /* check1 */ T::some_value {{{$}} +// CHECK-FIXES: Obj leading_comment_whitespace() requires /* check1 */ T::some_value { template <typename T> typename std::enable_if</* check1 */ T::some_value /* check2 */, Obj>::type leading_and_trailing_comment() { return Obj{}; } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj leading_and_trailing_comment() requires /* check1 */ T::some_value /* check2 */ {{{$}} +// CHECK-FIXES: Obj leading_and_trailing_comment() requires /* check1 */ T::some_value /* check2 */ { template <typename T, typename U> typename std::enable_if<T::some_value && @@ -385,31 +385,31 @@ typename std::enable_if<T::some_value && return Obj{}; } // CHECK-MESSAGES: :[[@LINE-4]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}Obj condition_on_two_lines() requires (T::some_value &&{{$}} -// CHECK-FIXES-NEXT: U::another_value) {{{$}} +// CHECK-FIXES: Obj condition_on_two_lines() requires (T::some_value && +// CHECK-FIXES-NEXT: U::another_value) { template <typename T> typename std::enable_if<T::some_value, int> :: type* pointer_of_enable_if_t_with_spaces() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if_t_with_spaces() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: int* pointer_of_enable_if_t_with_spaces() requires T::some_value { template <typename T> typename std::enable_if<T::some_value, int> :: /*c*/ type* pointer_of_enable_if_t_with_comment() { } // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}int* pointer_of_enable_if_t_with_comment() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: int* pointer_of_enable_if_t_with_comment() requires T::some_value { template <typename T> std::enable_if_t<T::some_value // comment > trailing_slash_slash_comment() { } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void trailing_slash_slash_comment() requires T::some_value // comment{{$}} -// CHECK-FIXES-NEXT: {{^}} {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void trailing_slash_slash_comment() requires T::some_value // comment +// CHECK-FIXES-NEXT: { } // namespace enable_if_in_return_type @@ -424,22 +424,22 @@ template <typename T, typename std::enable_if<T::some_value, int>::type = 0> void basic() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void basic() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void basic() requires T::some_value { template <typename T, std::enable_if_t<T::some_value, int> = 0> void basic_t() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void basic_t() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void basic_t() requires T::some_value { template <typename T, template <typename> class U, class V, std::enable_if_t<T::some_value, int> = 0> void basic_many_template_params() { } // CHECK-MESSAGES: :[[@LINE-3]]:61: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T, template <typename> class U, class V>{{$}} -// CHECK-FIXES-NEXT: {{^}}void basic_many_template_params() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T, template <typename> class U, class V> +// CHECK-FIXES-NEXT: void basic_many_template_params() requires T::some_value { template <std::enable_if_t<true, int> = 0> void no_dependent_type() { @@ -457,38 +457,37 @@ struct AClass : ABaseClass { void no_other_template_params() { } // CHECK-MESSAGES: :[[@LINE-3]]:13: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} {{$}} - // CHECK-FIXES-NEXT: {{^}} void no_other_template_params() requires T::some_value {{{$}} + // CHECK-FIXES: void no_other_template_params() requires T::some_value { template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass() {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass() requires U::some_value {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass() requires U::some_value {} template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass(int) : data(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int) requires U::some_value : data(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int) requires U::some_value : data(0) {} template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass(int, int) : AClass(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int, int) requires U::some_value : AClass(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int, int) requires U::some_value : AClass(0) {} template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass(int, int, int) : ABaseClass(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int, int, int) requires U::some_value : ABaseClass(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int, int, int) requires U::some_value : ABaseClass(0) {} template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass(int, int, int, int) : data2(), data() {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int, int, int, int) requires U::some_value : data2(), data() {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int, int, int, int) requires U::some_value : data2(), data() {} int data; int data2; @@ -500,14 +499,14 @@ struct AClass2 : ABaseClass { template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass2() {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass2() requires U::some_value {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass2() requires U::some_value {} template <typename U, std::enable_if_t<U::some_value, int> = 0> AClass2(int) : data2(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass2(int) requires U::some_value : data2(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass2(int) requires U::some_value : data2(0) {} int data = 10; int data2; @@ -518,16 +517,16 @@ template <typename T, std::enable_if_t<T::some_value, T>* = 0> void pointer_type() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void pointer_type() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void pointer_type() requires T::some_value { template <typename T, std::enable_if_t<T::some_value, T>* = nullptr> void param_on_newline() { } // CHECK-MESSAGES: :[[@LINE-3]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void param_on_newline() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void param_on_newline() requires T::some_value { template <typename T, typename U, @@ -537,26 +536,26 @@ template <typename T, void param_split_on_two_lines() { } // CHECK-MESSAGES: :[[@LINE-5]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T,{{$}} -// CHECK-FIXES-NEXT: {{^}} typename U>{{$}} -// CHECK-FIXES-NEXT: {{^}}void param_split_on_two_lines() requires ConsumeVariadic<T,{{$}} -// CHECK-FIXES-NEXT: {{^}} U>::value {{{$}} +// CHECK-FIXES: template <typename T, +// CHECK-FIXES-NEXT: typename U> +// CHECK-FIXES-NEXT: void param_split_on_two_lines() requires ConsumeVariadic<T, +// CHECK-FIXES-NEXT: U>::value { template <typename T, std::enable_if_t<T::some_value // comment >* = nullptr> void trailing_slash_slash_comment() { } // CHECK-MESSAGES: :[[@LINE-4]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void trailing_slash_slash_comment() requires T::some_value // comment{{$}} -// CHECK-FIXES-NEXT: {{^}} {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void trailing_slash_slash_comment() requires T::some_value // comment +// CHECK-FIXES-NEXT: { template <typename T, std::enable_if_t<T::some_value>* = nullptr, std::enable_if_t<T::another_value>* = nullptr> void two_enable_ifs() { } // CHECK-MESSAGES: :[[@LINE-3]]:67: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T, std::enable_if_t<T::some_value>* = nullptr>{{$}} -// CHECK-FIXES-NEXT: {{^}}void two_enable_ifs() requires T::another_value {{{$}} +// CHECK-FIXES: template <typename T, std::enable_if_t<T::some_value>* = nullptr> +// CHECK-FIXES-NEXT: void two_enable_ifs() requires T::another_value { //////////////////////////////// // Negative tests @@ -584,16 +583,16 @@ void macro_entire_enable_if() { } // CHECK-MESSAGES: :[[@LINE-3]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] // CHECK-MESSAGES: :[[@LINE-5]]:56: note: expanded from macro 'TEMPLATE_REQUIRES' -// CHECK-FIXES: {{^}}TEMPLATE_REQUIRES(U, U::some_value) -// CHECK-FIXES-NEXT: {{^}}void macro_entire_enable_if() {{{$}} +// CHECK-FIXES: TEMPLATE_REQUIRES(U, U::some_value) +// CHECK-FIXES-NEXT: void macro_entire_enable_if() { #define CONDITION U::some_value template <typename U, std::enable_if_t<CONDITION, int> = 0> void macro_condition() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename U>{{$}} -// CHECK-FIXES-NEXT: {{^}}void macro_condition() requires CONDITION {{{$}} +// CHECK-FIXES: template <typename U> +// CHECK-FIXES-NEXT: void macro_condition() requires CONDITION { #undef CONDITION #define CONDITION !U::some_value @@ -601,8 +600,8 @@ template <typename U, std::enable_if_t<CONDITION, int> = 0> void macro_condition_not_primary() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename U>{{$}} -// CHECK-FIXES-NEXT: {{^}}void macro_condition_not_primary() requires (CONDITION) {{{$}} +// CHECK-FIXES: template <typename U> +// CHECK-FIXES-NEXT: void macro_condition_not_primary() requires (CONDITION) { } // namespace enable_if_trailing_non_type_parameter @@ -617,22 +616,22 @@ template <typename T, typename = std::enable_if<T::some_value>::type> void basic() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void basic() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void basic() requires T::some_value { template <typename T, typename = std::enable_if_t<T::some_value>> void basic_t() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void basic_t() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void basic_t() requires T::some_value { template <typename T, template <typename> class U, class V, typename = std::enable_if_t<T::some_value>> void basic_many_template_params() { } // CHECK-MESSAGES: :[[@LINE-3]]:61: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T, template <typename> class U, class V>{{$}} -// CHECK-FIXES-NEXT: {{^}}void basic_many_template_params() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T, template <typename> class U, class V> +// CHECK-FIXES-NEXT: void basic_many_template_params() requires T::some_value { struct ABaseClass { ABaseClass(); @@ -645,32 +644,31 @@ struct AClass : ABaseClass { void no_other_template_params() { } // CHECK-MESSAGES: :[[@LINE-3]]:13: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} {{$}} - // CHECK-FIXES-NEXT: {{^}} void no_other_template_params() requires T::some_value {{{$}} + // CHECK-FIXES: void no_other_template_params() requires T::some_value { template <typename U, typename = std::enable_if_t<U::some_value>> AClass() {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass() requires U::some_value {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass() requires U::some_value {} template <typename U, typename = std::enable_if_t<U::some_value>> AClass(int) : data(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int) requires U::some_value : data(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int) requires U::some_value : data(0) {} template <typename U, typename = std::enable_if_t<U::some_value>> AClass(int, int) : AClass(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int, int) requires U::some_value : AClass(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int, int) requires U::some_value : AClass(0) {} template <typename U, typename = std::enable_if_t<U::some_value>> AClass(int, int, int) : ABaseClass(0) {} // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] - // CHECK-FIXES: {{^}} template <typename U>{{$}} - // CHECK-FIXES-NEXT: {{^}} AClass(int, int, int) requires U::some_value : ABaseClass(0) {}{{$}} + // CHECK-FIXES: template <typename U> + // CHECK-FIXES-NEXT: AClass(int, int, int) requires U::some_value : ABaseClass(0) {} int data; }; @@ -679,23 +677,23 @@ template <typename T, typename = std::enable_if_t<T::some_value>*> void pointer_type() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void pointer_type() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void pointer_type() requires T::some_value { template <typename T, typename = std::enable_if_t<T::some_value>&> void reference_type() { } // CHECK-MESSAGES: :[[@LINE-3]]:23: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void reference_type() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void reference_type() requires T::some_value { template <typename T, typename = std::enable_if_t<T::some_value>*> void param_on_newline() { } // CHECK-MESSAGES: :[[@LINE-3]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T>{{$}} -// CHECK-FIXES-NEXT: {{^}}void param_on_newline() requires T::some_value {{{$}} +// CHECK-FIXES: template <typename T> +// CHECK-FIXES-NEXT: void param_on_newline() requires T::some_value { template <typename T, typename U, @@ -705,10 +703,10 @@ template <typename T, void param_split_on_two_lines() { } // CHECK-MESSAGES: :[[@LINE-5]]:11: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}template <typename T,{{$}} -// CHECK-FIXES-NEXT: {{^}} typename U>{{$}} -// CHECK-FIXES-NEXT: {{^}}void param_split_on_two_lines() requires ConsumeVariadic<T,{{$}} -// CHECK-FIXES-NEXT: {{^}} U>::value {{{$}} +// CHECK-FIXES: template <typename T, +// CHECK-FIXES-NEXT: typename U> +// CHECK-FIXES-NEXT: void param_split_on_two_lines() requires ConsumeVariadic<T, +// CHECK-FIXES-NEXT: U>::value { //////////////////////////////// @@ -776,12 +774,12 @@ using enable_if_t = typename enable_if<Condition, T>::type; template <typename T> typename nonstd::enable_if<some_type_trait<T>::value, void>::type nonstd_enable_if() {} // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void nonstd_enable_if() requires some_type_trait<T>::value {}{{$}} +// CHECK-FIXES: void nonstd_enable_if() requires some_type_trait<T>::value {} template <typename T> nonstd::enable_if_t<some_type_trait<T>::value, void> nonstd_enable_if_t() {} // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void nonstd_enable_if_t() requires some_type_trait<T>::value {}{{$}} +// CHECK-FIXES: void nonstd_enable_if_t() requires some_type_trait<T>::value {} template <> nonstd::enable_if_t<some_type_trait<int>::value, void> nonstd_enable_if_t<int>() {} @@ -790,12 +788,12 @@ nonstd::enable_if_t<some_type_trait<int>::value, void> nonstd_enable_if_t<int>() template <typename T> typename nonstd::enable_if<some_type_trait<T>::value>::type nonstd_enable_if_one_param() {} // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void nonstd_enable_if_one_param() requires some_type_trait<T>::value {}{{$}} +// CHECK-FIXES: void nonstd_enable_if_one_param() requires some_type_trait<T>::value {} template <typename T> nonstd::enable_if_t<some_type_trait<T>::value> nonstd_enable_if_t_one_param() {} // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use C++20 requires constraints instead of enable_if [modernize-use-constraints] -// CHECK-FIXES: {{^}}void nonstd_enable_if_t_one_param() requires some_type_trait<T>::value {}{{$}} +// CHECK-FIXES: void nonstd_enable_if_t_one_param() requires some_type_trait<T>::value {} // No fix-its are offered for an enable_if with a different signature from the standard one. namespace boost { diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init-assignment.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init-assignment.cpp index cf0df44..5a868e2 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init-assignment.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init-assignment.cpp @@ -197,32 +197,32 @@ class ArrayValueInit { ArrayValueInit() : m_array() {} double m_array[1]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayValueInit() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[1] = {}; + // CHECK-FIXES: ArrayValueInit() {} + // CHECK-FIXES-NEXT: double m_array[1] = {}; }; class ArrayBraceInit { ArrayBraceInit() : m_array{} {} double m_array[1]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayBraceInit() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[1] = {}; + // CHECK-FIXES: ArrayBraceInit() {} + // CHECK-FIXES-NEXT: double m_array[1] = {}; }; class ArrayBraceInitWithValue { ArrayBraceInitWithValue() : m_array{3.14} {} double m_array[1]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayBraceInitWithValue() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[1] = {3.14}; + // CHECK-FIXES: ArrayBraceInitWithValue() {} + // CHECK-FIXES-NEXT: double m_array[1] = {3.14}; }; class ArrayBraceInitMultipleValues { ArrayBraceInitMultipleValues() : m_array{1.0, 2.0, 3.0} {} double m_array[3]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayBraceInitMultipleValues() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[3] = {1.0, 2.0, 3.0}; + // CHECK-FIXES: ArrayBraceInitMultipleValues() {} + // CHECK-FIXES-NEXT: double m_array[3] = {1.0, 2.0, 3.0}; }; } // namespace PR63285 diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init.cpp index 52b15de..3273501 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-default-member-init.cpp @@ -479,8 +479,8 @@ struct EmptyBracedIntDefault { EmptyBracedIntDefault() : m_i{} {} int m_i; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use default member initializer for 'm_i' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}EmptyBracedIntDefault() {} - // CHECK-FIXES-NEXT: {{^ }}int m_i{}; + // CHECK-FIXES: EmptyBracedIntDefault() {} + // CHECK-FIXES-NEXT: int m_i{}; }; namespace PR63285 { @@ -489,32 +489,32 @@ class ArrayValueInit { ArrayValueInit() : m_array() {} double m_array[1]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayValueInit() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[1]{}; + // CHECK-FIXES: ArrayValueInit() {} + // CHECK-FIXES-NEXT: double m_array[1]{}; }; class ArrayBraceInit { ArrayBraceInit() : m_array{} {} double m_array[1]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayBraceInit() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[1]{}; + // CHECK-FIXES: ArrayBraceInit() {} + // CHECK-FIXES-NEXT: double m_array[1]{}; }; class ArrayBraceInitWithValue { ArrayBraceInitWithValue() : m_array{3.14} {} double m_array[1]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayBraceInitWithValue() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[1]{3.14}; + // CHECK-FIXES: ArrayBraceInitWithValue() {} + // CHECK-FIXES-NEXT: double m_array[1]{3.14}; }; class ArrayBraceInitMultipleValues { ArrayBraceInitMultipleValues() : m_array{1.0, 2.0, 3.0} {} double m_array[3]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use default member initializer for 'm_array' [modernize-use-default-member-init] - // CHECK-FIXES: {{^ }}ArrayBraceInitMultipleValues() {} - // CHECK-FIXES-NEXT: {{^ }}double m_array[3]{1.0, 2.0, 3.0}; + // CHECK-FIXES: ArrayBraceInitMultipleValues() {} + // CHECK-FIXES-NEXT: double m_array[3]{1.0, 2.0, 3.0}; }; } // namespace PR63285 diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default-copy.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default-copy.cpp index 6520620..9639e0e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default-copy.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default-copy.cpp @@ -147,7 +147,7 @@ struct BF { BF(const BF &Other) : Field1(Other.Field1), Field2(Other.Field2), Field3(Other.Field3), Field4(Other.Field4) {}; // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: use '= default' - // CHECK-FIXES: BF(const BF &Other) {{$}} + // CHECK-FIXES: BF(const BF &Other) // CHECK-FIXES: = default; BF &operator=(const BF &); diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default.cpp index 209ca7d..a606b84 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-equals-default.cpp @@ -127,7 +127,7 @@ Priv::Priv() {} struct SemiColon { SemiColon() {}; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default' - // CHECK-FIXES: SemiColon() = default;{{$}} + // CHECK-FIXES: SemiColon() = default; }; struct SemiColonOutOfLine { @@ -136,16 +136,16 @@ struct SemiColonOutOfLine { SemiColonOutOfLine::SemiColonOutOfLine() {}; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use '= default' -// CHECK-FIXES: SemiColonOutOfLine::SemiColonOutOfLine() = default;{{$}} +// CHECK-FIXES: SemiColonOutOfLine::SemiColonOutOfLine() = default; // struct. struct ST { ST() {} // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default' - // CHECK-FIXES: ST() = default;{{$}} + // CHECK-FIXES: ST() = default; ~ST() {} // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default' - // CHECK-FIXES: ST() = default;{{$}} + // CHECK-FIXES: ST() = default; }; // Deleted constructor/destructor. @@ -238,13 +238,13 @@ struct DC : KW { DC() : KW() {} ~DC() override {} // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default' - // CHECK-FIXES: ~DC() override = default;{{$}} + // CHECK-FIXES: ~DC() override = default; }; struct OverrideWithSemiColon : KW { ~OverrideWithSemiColon() override {}; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= default' - // CHECK-FIXES: ~OverrideWithSemiColon() override = default;{{$}} + // CHECK-FIXES: ~OverrideWithSemiColon() override = default; }; struct Comments { diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-allow-override-and-final.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-allow-override-and-final.cpp index b6c3e0a..8a6024c 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-allow-override-and-final.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-allow-override-and-final.cpp @@ -17,24 +17,24 @@ struct Base { struct Simple : public Base { virtual ~Simple(); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} ~Simple() override; + // CHECK-FIXES: ~Simple() override; virtual void a() override; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] - // CHECK-FIXES: {{^}} void a() override; + // CHECK-FIXES: void a() override; virtual void b() final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'final' [modernize-use-override] - // CHECK-FIXES: {{^}} void b() final; + // CHECK-FIXES: void b() final; virtual void c() final override; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'final' [modernize-use-override] - // CHECK-FIXES: {{^}} void c() final override; + // CHECK-FIXES: void c() final override; virtual void d() override final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'final' [modernize-use-override] - // CHECK-FIXES: {{^}} void d() override final; + // CHECK-FIXES: void d() override final; void e() final override; void f() override final; void g() final; void h() override; void i(); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] - // CHECK-FIXES: {{^}} void i() override; + // CHECK-FIXES: void i() override; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-ms.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-ms.cpp index e7c0089..a272043 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-ms.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-ms.cpp @@ -14,12 +14,12 @@ class EXPORT InheritedBase { class Derived : public Base { virtual EXPORT void a(); // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} EXPORT void a() override; + // CHECK-FIXES: EXPORT void a() override; }; class EXPORT InheritedDerived : public InheritedBase { virtual void a(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} void a() override; + // CHECK-FIXES: void a() override; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-no-destructors.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-no-destructors.cpp index 2012d71..97e2220 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-no-destructors.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-no-destructors.cpp @@ -11,5 +11,5 @@ struct Simple : public Base { // CHECK-MESSAGES-NOT: warning: virtual void f(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void f() override; + // CHECK-FIXES: void f() override; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-templates.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-templates.cpp index a06ada8..631f0d7 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-templates.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-templates.cpp @@ -43,5 +43,5 @@ struct Derived2 : BaseS<T>, BaseU { // should warn, comes from non-template BaseU virtual void boo3(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^ }}void boo3() override; + // CHECK-FIXES: void boo3() override; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-macro.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-macro.cpp index f9ac6d4..0e9a186 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-macro.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-macro.cpp @@ -29,41 +29,41 @@ struct SimpleCases : public Base { public: virtual ~SimpleCases(); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using 'OVERRIDE' or (rarely) 'FINAL' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} ~SimpleCases() OVERRIDE; + // CHECK-FIXES: ~SimpleCases() OVERRIDE; void a(); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this function with 'OVERRIDE' or (rarely) 'FINAL' [modernize-use-override] - // CHECK-FIXES: {{^}} void a() OVERRIDE; + // CHECK-FIXES: void a() OVERRIDE; virtual void b(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using 'OVERRIDE' or (rarely) 'FINAL' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} void b() OVERRIDE; + // CHECK-FIXES: void b() OVERRIDE; virtual void c(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void c() OVERRIDE; + // CHECK-FIXES: void c() OVERRIDE; virtual void e() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void e() OVERRIDE = 0; + // CHECK-FIXES: void e() OVERRIDE = 0; virtual void f2() const = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void f2() const OVERRIDE = 0; + // CHECK-FIXES: void f2() const OVERRIDE = 0; virtual void g() ABSTRACT; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void g() OVERRIDE ABSTRACT; + // CHECK-FIXES: void g() OVERRIDE ABSTRACT; virtual void j() const; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void j() const OVERRIDE; + // CHECK-FIXES: void j() const OVERRIDE; virtual void k() OVERRIDE; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'OVERRIDE' [modernize-use-override] - // CHECK-FIXES: {{^}} void k() OVERRIDE; + // CHECK-FIXES: void k() OVERRIDE; virtual void l() const OVERRIDE; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'OVERRIDE' [modernize-use-override] - // CHECK-FIXES: {{^}} void l() const OVERRIDE; + // CHECK-FIXES: void l() const OVERRIDE; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-no-macro-inscope.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-no-macro-inscope.cpp index 924dd53..f348147 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-no-macro-inscope.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-with-no-macro-inscope.cpp @@ -15,13 +15,13 @@ struct SimpleCases : public Base { public: virtual ~SimpleCases(); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using 'CUSTOM_OVERRIDE' or (rarely) 'CUSTOM_FINAL' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} virtual ~SimpleCases(); + // CHECK-FIXES: virtual ~SimpleCases(); void a(); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this function with 'CUSTOM_OVERRIDE' or (rarely) 'CUSTOM_FINAL' [modernize-use-override] - // CHECK-FIXES: {{^}} void a(); + // CHECK-FIXES: void a(); virtual void b(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using 'CUSTOM_OVERRIDE' or (rarely) 'CUSTOM_FINAL' instead of 'virtual' [modernize-use-override] - // CHECK-FIXES: {{^}} virtual void b(); + // CHECK-FIXES: virtual void b(); }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override.cpp index c5745e3..809e435 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-override.cpp @@ -54,182 +54,182 @@ struct SimpleCases : public Base { public: virtual ~SimpleCases(); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' - // CHECK-FIXES: {{^}} ~SimpleCases() override; + // CHECK-FIXES: ~SimpleCases() override; void a(); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this - // CHECK-FIXES: {{^}} void a() override; + // CHECK-FIXES: void a() override; void b() override; // CHECK-MESSAGES-NOT: warning: - // CHECK-FIXES: {{^}} void b() override; + // CHECK-FIXES: void b() override; virtual void c(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void c() override; + // CHECK-FIXES: void c() override; virtual void d() override; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'override' - // CHECK-FIXES: {{^}} void d() override; + // CHECK-FIXES: void d() override; virtual void d2() final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant since the function is already declared 'final' - // CHECK-FIXES: {{^}} void d2() final; + // CHECK-FIXES: void d2() final; virtual void e() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void e() override = 0; + // CHECK-FIXES: void e() override = 0; virtual void f()=0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void f() override =0; + // CHECK-FIXES: void f() override =0; virtual void f2() const=0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void f2() const override =0; + // CHECK-FIXES: void f2() const override =0; virtual void g() ABSTRACT; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void g() override ABSTRACT; + // CHECK-FIXES: void g() override ABSTRACT; virtual void j() const; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void j() const override; + // CHECK-FIXES: void j() const override; virtual MustUseResultObject k(); // Has an implicit attribute. // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: prefer using - // CHECK-FIXES: {{^}} MustUseResultObject k() override; + // CHECK-FIXES: MustUseResultObject k() override; virtual bool l() MUST_USE_RESULT UNUSED; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} bool l() override MUST_USE_RESULT UNUSED; + // CHECK-FIXES: bool l() override MUST_USE_RESULT UNUSED; virtual bool n() UNUSED MUST_USE_RESULT; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} bool n() override UNUSED MUST_USE_RESULT; + // CHECK-FIXES: bool n() override UNUSED MUST_USE_RESULT; void m() override final; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'override' is redundant since the function is already declared 'final' - // CHECK-FIXES: {{^}} void m() final; + // CHECK-FIXES: void m() final; virtual void m2() override final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' and 'override' are redundant since the function is already declared 'final' - // CHECK-FIXES: {{^}} void m2() final; + // CHECK-FIXES: void m2() final; virtual void o() __attribute__((unused)); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void o() override __attribute__((unused)); + // CHECK-FIXES: void o() override __attribute__((unused)); virtual void ne() noexcept(false); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void ne() noexcept(false) override; + // CHECK-FIXES: void ne() noexcept(false) override; virtual void t() throw(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void t() throw() override; + // CHECK-FIXES: void t() throw() override; virtual /* */ void g2(); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' - // CHECK-FIXES: {{^}} /* */ void g2() override; + // CHECK-FIXES: /* */ void g2() override; }; // CHECK-MESSAGES-NOT: warning: void SimpleCases::c() {} -// CHECK-FIXES: {{^}}void SimpleCases::c() {} +// CHECK-FIXES: void SimpleCases::c() {} SimpleCases::~SimpleCases() {} -// CHECK-FIXES: {{^}}SimpleCases::~SimpleCases() {} +// CHECK-FIXES: SimpleCases::~SimpleCases() {} struct DefaultedDestructor : public Base { DefaultedDestructor() {} virtual ~DefaultedDestructor() = default; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using - // CHECK-FIXES: {{^}} ~DefaultedDestructor() override = default; + // CHECK-FIXES: ~DefaultedDestructor() override = default; }; struct FinalSpecified : public Base { public: virtual ~FinalSpecified() final; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'virtual' is redundant since the function is already declared 'final' - // CHECK-FIXES: {{^}} ~FinalSpecified() final; + // CHECK-FIXES: ~FinalSpecified() final; void b() final; // CHECK-MESSAGES-NOT: warning: - // CHECK-FIXES: {{^}} void b() final; + // CHECK-FIXES: void b() final; virtual void d() final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant - // CHECK-FIXES: {{^}} void d() final; + // CHECK-FIXES: void d() final; virtual void e() final = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant - // CHECK-FIXES: {{^}} void e() final = 0; + // CHECK-FIXES: void e() final = 0; virtual void j() const final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant - // CHECK-FIXES: {{^}} void j() const final; + // CHECK-FIXES: void j() const final; virtual bool l() final MUST_USE_RESULT UNUSED; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant - // CHECK-FIXES: {{^}} bool l() final MUST_USE_RESULT UNUSED; + // CHECK-FIXES: bool l() final MUST_USE_RESULT UNUSED; }; struct InlineDefinitions : public Base { public: virtual ~InlineDefinitions() {} // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using - // CHECK-FIXES: {{^}} ~InlineDefinitions() override {} + // CHECK-FIXES: ~InlineDefinitions() override {} void a() {} // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this - // CHECK-FIXES: {{^}} void a() override {} + // CHECK-FIXES: void a() override {} void b() override {} // CHECK-MESSAGES-NOT: warning: - // CHECK-FIXES: {{^}} void b() override {} + // CHECK-FIXES: void b() override {} virtual void c() {} // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void c() override + // CHECK-FIXES: void c() override virtual void d() override {} // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant - // CHECK-FIXES: {{^}} void d() override {} + // CHECK-FIXES: void d() override {} virtual void j() const {} // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void j() const override + // CHECK-FIXES: void j() const override virtual MustUseResultObject k(); // Has an implicit attribute. // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: prefer using - // CHECK-FIXES: {{^}} MustUseResultObject k() override; + // CHECK-FIXES: MustUseResultObject k() override; virtual bool l() MUST_USE_RESULT UNUSED; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} bool l() override MUST_USE_RESULT UNUSED; + // CHECK-FIXES: bool l() override MUST_USE_RESULT UNUSED; virtual void r() & {} // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void r() & override + // CHECK-FIXES: void r() & override virtual void rr() && {} // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void rr() && override + // CHECK-FIXES: void rr() && override virtual void cv() const volatile {} // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void cv() const volatile override + // CHECK-FIXES: void cv() const volatile override virtual void cv2() const volatile // some comment {} // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void cv2() const volatile override // some comment + // CHECK-FIXES: void cv2() const volatile override // some comment }; struct DefaultArguments : public Base { @@ -237,7 +237,7 @@ struct DefaultArguments : public Base { // Make sure the override fix is placed after the argument list. void il(IntPair p = {1, (2 + (3))}) {} // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this - // CHECK-FIXES: {{^}} void il(IntPair p = {1, (2 + (3))}) override {} + // CHECK-FIXES: void il(IntPair p = {1, (2 + (3))}) override {} }; struct Macros : public Base { @@ -245,31 +245,31 @@ struct Macros : public Base { // give up for now. NOT_VIRTUAL void a() NOT_OVERRIDE; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: annotate this - // CHECK-FIXES: {{^}} NOT_VIRTUAL void a() override NOT_OVERRIDE; + // CHECK-FIXES: NOT_VIRTUAL void a() override NOT_OVERRIDE; VIRTUAL void b() NOT_OVERRIDE; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} VIRTUAL void b() override NOT_OVERRIDE; + // CHECK-FIXES: VIRTUAL void b() override NOT_OVERRIDE; NOT_VIRTUAL void c() OVERRIDE; // CHECK-MESSAGES-NOT: warning: - // CHECK-FIXES: {{^}} NOT_VIRTUAL void c() OVERRIDE; + // CHECK-FIXES: NOT_VIRTUAL void c() OVERRIDE; VIRTUAL void d() OVERRIDE; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' is redundant - // CHECK-FIXES: {{^}} VIRTUAL void d() OVERRIDE; + // CHECK-FIXES: VIRTUAL void d() OVERRIDE; #define FUNC(return_type, name) return_type name() FUNC(void, e); - // CHECK-FIXES: {{^}} FUNC(void, e); + // CHECK-FIXES: FUNC(void, e); #define F virtual void f(); F - // CHECK-FIXES: {{^}} F + // CHECK-FIXES: F VIRTUAL void g() OVERRIDE final; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 'virtual' and 'override' are redundant - // CHECK-FIXES: {{^}} VIRTUAL void g() final; + // CHECK-FIXES: VIRTUAL void g() final; }; // Tests for templates. @@ -280,7 +280,7 @@ template <typename T> struct TemplateBase { template <typename T> struct DerivedFromTemplate : public TemplateBase<T> { virtual void f(T t); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void f(T t) override; + // CHECK-FIXES: void f(T t) override; }; void f() { DerivedFromTemplate<int>().f(2); } @@ -288,7 +288,7 @@ template <class C> struct UnusedMemberInstantiation : public C { virtual ~UnusedMemberInstantiation() {} // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using - // CHECK-FIXES: {{^}} ~UnusedMemberInstantiation() override {} + // CHECK-FIXES: ~UnusedMemberInstantiation() override {} }; struct IntantiateWithoutUse : public UnusedMemberInstantiation<Base> {}; @@ -303,7 +303,7 @@ template <int I> struct MembersOfSpecializations : public Base2 { void a() override; // CHECK-MESSAGES-NOT: warning: - // CHECK-FIXES: {{^}} void a() override; + // CHECK-FIXES: void a() override; }; template <> void MembersOfSpecializations<3>::a() {} void ff() { MembersOfSpecializations<3>().a(); }; @@ -313,11 +313,11 @@ void ff() { MembersOfSpecializations<3>().a(); }; struct TryStmtAsBody : public Base { void a() try // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this - // CHECK-FIXES: {{^}} void a() override try + // CHECK-FIXES: void a() override try { b(); } catch(...) { c(); } virtual void d() try // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using - // CHECK-FIXES: {{^}} void d() override try + // CHECK-FIXES: void d() override try { e(); } catch(...) { f(); } }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-cxx20.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-cxx20.cpp index 8a0618d..dd45094 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-cxx20.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-cxx20.cpp @@ -17,11 +17,11 @@ concept floating_point = std::is_same<T, float>::value || std::is_same<T, double std::floating_point auto con1(); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto con1() -> std::floating_point auto;{{$}} +// CHECK-FIXES: auto con1() -> std::floating_point auto; std::floating_point auto con1() { return 3.14f; } // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto con1() -> std::floating_point auto { return 3.14f; }{{$}} +// CHECK-FIXES: auto con1() -> std::floating_point auto { return 3.14f; } namespace a { template <typename T> @@ -33,25 +33,25 @@ concept BinaryConcept = true; a::Concept decltype(auto) con2(); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto con2() -> a::Concept decltype(auto);{{$}} +// CHECK-FIXES: auto con2() -> a::Concept decltype(auto); a::BinaryConcept<int> decltype(auto) con3(); // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto con3() -> a::BinaryConcept<int> decltype(auto);{{$}} +// CHECK-FIXES: auto con3() -> a::BinaryConcept<int> decltype(auto); const std::floating_point auto* volatile con4(); // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto con4() -> const std::floating_point auto* volatile;{{$}} +// CHECK-FIXES: auto con4() -> const std::floating_point auto* volatile; template <typename T> int req1(T t) requires std::floating_point<T>; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto req1(T t) -> int requires std::floating_point<T>;{{$}} +// CHECK-FIXES: auto req1(T t) -> int requires std::floating_point<T>; template <typename T> T req2(T t) requires requires { t + t; }; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a trailing return type for this function [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}}auto req2(T t) -> T requires requires { t + t; };{{$}} + // CHECK-FIXES: auto req2(T t) -> T requires requires { t + t; }; // // Operator c++20 defaulted comparison operators @@ -96,7 +96,7 @@ struct TestDefaultOperatorB { friend auto operator==(const TestDefaultOperatorB &, const TestDefaultOperatorB &) noexcept -> bool = default; friend bool operator<(const TestDefaultOperatorB &, const TestDefaultOperatorB &) noexcept = default; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use a trailing return type for this function [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} friend auto operator<(const TestDefaultOperatorB &, const TestDefaultOperatorB &) noexcept -> bool = default;{{$}} + // CHECK-FIXES: friend auto operator<(const TestDefaultOperatorB &, const TestDefaultOperatorB &) noexcept -> bool = default; }; namespace PR69863 { @@ -109,7 +109,7 @@ struct CustomCompileTimeString { template <CustomCompileTimeString Str> constexpr decltype(Str) operator""__csz() noexcept { // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}constexpr auto operator""__csz() noexcept -> decltype(Str) { +// CHECK-FIXES: constexpr auto operator""__csz() noexcept -> decltype(Str) { return Str; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx14.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx14.cpp index 33051c6..cd88c84 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx14.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx14.cpp @@ -10,15 +10,15 @@ namespace std { void test_lambda_positive() { auto l1 = [](auto x) { return x; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l1 = [](auto x) -> auto { return x; };{{$}} + // CHECK-FIXES: auto l1 = [](auto x) -> auto { return x; }; } template <template <typename> class C> void test_lambda_positive_template() { auto l1 = []() { return C<int>{}; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l1 = []() -> auto { return C<int>{}; };{{$}} + // CHECK-FIXES: auto l1 = []() -> auto { return C<int>{}; }; auto l2 = []() { return 0; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l2 = []() -> auto { return 0; };{{$}} + // CHECK-FIXES: auto l2 = []() -> auto { return 0; }; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp index 521b5c6..83b9b84 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp @@ -14,22 +14,22 @@ concept floating_point = std::is_same<T, float>::value || std::is_same<T, double void test_lambda_positive() { auto l1 = []<typename T, typename U>(T x, U y) { return x + y; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l1 = []<typename T, typename U>(T x, U y) -> auto { return x + y; };{{$}} + // CHECK-FIXES: auto l1 = []<typename T, typename U>(T x, U y) -> auto { return x + y; }; auto l2 = [](auto x) requires requires { x + x; } { return x; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l2 = [](auto x) -> auto requires requires { x + x; } { return x; };{{$}} + // CHECK-FIXES: auto l2 = [](auto x) -> auto requires requires { x + x; } { return x; }; auto l3 = [](auto x) requires std::floating_point<decltype(x)> { return x; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l3 = [](auto x) -> auto requires std::floating_point<decltype(x)> { return x; };{{$}} + // CHECK-FIXES: auto l3 = [](auto x) -> auto requires std::floating_point<decltype(x)> { return x; }; auto l4 = [](int x) consteval { return x; }; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l4 = [](int x) consteval -> int { return x; };{{$}} + // CHECK-FIXES: auto l4 = [](int x) consteval -> int { return x; }; // Complete complex example auto l5 = []<typename T, typename U>(T x, U y) constexpr noexcept requires std::floating_point<T> && std::floating_point<U> { return x * y; }; // CHECK-MESSAGES: :[[@LINE-3]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES: {{^}} auto l5 = []<typename T, typename U>(T x, U y) constexpr noexcept{{$}} - // CHECK-FIXES: {{^}} -> auto requires std::floating_point<T> && std::floating_point<U>{{$}} - // CHECK-FIXES: {{^}} { return x * y; };{{$}} + // CHECK-FIXES: auto l5 = []<typename T, typename U>(T x, U y) constexpr noexcept + // CHECK-FIXES: -> auto requires std::floating_point<T> && std::floating_point<U> + // CHECK-FIXES: { return x * y; }; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp index 0b7e7a1..3d2d94e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp @@ -22,19 +22,19 @@ void test_lambda_positive() { auto l01 = [] {}; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:14: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:14: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l01 = [] -> void {};{{$}} + // CHECK-FIXES-ALL: auto l01 = [] -> void {}; auto l1 = []() {}; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l1 = []() -> void {};{{$}} + // CHECK-FIXES-ALL: auto l1 = []() -> void {}; auto l2 = []() { return 42; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l2 = []() -> int { return 42; };{{$}} + // CHECK-FIXES-ALL: auto l2 = []() -> int { return 42; }; auto l3 = [](int x, double y) { return x * y; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l3 = [](int x, double y) -> double { return x * y; };{{$}} + // CHECK-FIXES-ALL: auto l3 = [](int x, double y) -> double { return x * y; }; int capture_int = 10; double capture_double = 3.14; @@ -43,31 +43,31 @@ void test_lambda_positive() { auto l4 = [capture_int]() { return capture_int; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l4 = [capture_int]() -> int { return capture_int; };{{$}} + // CHECK-FIXES-ALL: auto l4 = [capture_int]() -> int { return capture_int; }; auto l5 = [capture_int, &capture_double](char c) { return capture_int + capture_double + c; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l5 = [capture_int, &capture_double](char c) -> double { return capture_int + capture_double + c; };{{$}} + // CHECK-FIXES-ALL: auto l5 = [capture_int, &capture_double](char c) -> double { return capture_int + capture_double + c; }; auto l6 = [capture_int]() constexpr mutable noexcept { return ++capture_int; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l6 = [capture_int]() constexpr mutable noexcept -> int { return ++capture_int; };{{$}} + // CHECK-FIXES-ALL: auto l6 = [capture_int]() constexpr mutable noexcept -> int { return ++capture_int; }; auto l7 = [&capture_ptr]() { return capture_ptr; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l7 = [&capture_ptr]() -> int * { return capture_ptr; };{{$}} + // CHECK-FIXES-ALL: auto l7 = [&capture_ptr]() -> int * { return capture_ptr; }; auto l8 = [&capture_int]() { return capture_int; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l8 = [&capture_int]() -> int { return capture_int; };{{$}} + // CHECK-FIXES-ALL: auto l8 = [&capture_int]() -> int { return capture_int; }; auto l9 = [] { return std::vector<std::vector<int>>{}; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l9 = [] -> std::vector<std::vector<int>> { return std::vector<std::vector<int>>{}; };{{$}} + // CHECK-FIXES-ALL: auto l9 = [] -> std::vector<std::vector<int>> { return std::vector<std::vector<int>>{}; }; auto l10 = [] { const char* const * const * const ptr = nullptr; return ptr; }; // CHECK-MESSAGES-ALL: :[[@LINE-1]]:14: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:14: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type] - // CHECK-FIXES-ALL: {{^}} auto l10 = [] -> const char *const *const * { const char* const * const * const ptr = nullptr; return ptr; };{{$}} + // CHECK-FIXES-ALL: auto l10 = [] -> const char *const *const * { const char* const * const * const ptr = nullptr; return ptr; }; } // In c++11 mode we can not write 'auto' type, see *-cxx14.cpp for fixes. @@ -86,4 +86,4 @@ void test_lambda_negative() { // this function is solely used to not to get "wrong config error" from the check. int f(); // CHECK-MESSAGES-NONE: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES-NONE: {{^}}auto f() -> int;{{$}} +// CHECK-FIXES-NONE: auto f() -> int; diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type.cpp index c16c033..6c91940 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type.cpp @@ -27,25 +27,25 @@ namespace std { int f(); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto f() -> int;{{$}} +// CHECK-FIXES: auto f() -> int; int ((f))(); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto ((f))() -> int;{{$}} +// CHECK-FIXES: auto ((f))() -> int; int f(int); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto f(int) -> int;{{$}} +// CHECK-FIXES: auto f(int) -> int; int f(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto f(int arg) -> int;{{$}} +// CHECK-FIXES: auto f(int arg) -> int; int f(int arg1, int arg2, int arg3); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto f(int arg1, int arg2, int arg3) -> int;{{$}} +// CHECK-FIXES: auto f(int arg1, int arg2, int arg3) -> int; int f(int arg1, int arg2, int arg3, ...); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto f(int arg1, int arg2, int arg3, ...) -> int;{{$}} +// CHECK-FIXES: auto f(int arg1, int arg2, int arg3, ...) -> int; template <typename T> int f(T t); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}template <typename T> auto f(T t) -> int;{{$}} +// CHECK-FIXES: template <typename T> auto f(T t) -> int; // // Functions with formatting @@ -53,44 +53,44 @@ template <typename T> int f(T t); int a1() { return 42; } // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a1() -> int { return 42; }{{$}} +// CHECK-FIXES: auto a1() -> int { return 42; } int a2() { return 42; } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a2() -> int {{{$}} +// CHECK-FIXES: auto a2() -> int { int a3() { return 42; } // CHECK-MESSAGES: :[[@LINE-4]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a3() -> int{{$}} +// CHECK-FIXES: auto a3() -> int int a4(int arg ) ; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a4(int arg ) -> int ;{{$}} +// CHECK-FIXES: auto a4(int arg ) -> int ; int a5 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a5{{$}} +// CHECK-FIXES: auto a5 (int arg); -// CHECK-FIXES: {{^}}(int arg) -> int;{{$}} +// CHECK-FIXES: (int arg) -> int; const int * a7 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use a trailing return type for this function [modernize-use-trailing-return-type] () -// CHECK-FIXES: {{^}}() -> const{{$}} -// CHECK-FIXES: {{^}}int{{$}} -// CHECK-FIXES: {{^}}*{{$}} +// CHECK-FIXES: () -> const +// CHECK-FIXES: int +// CHECK-FIXES: * ; int*a7(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a7(int arg) -> int*;{{$}} +// CHECK-FIXES: auto a7(int arg) -> int*; template<template <typename> class C> C<int>a8(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto a8(int arg) -> C<int>;{{$}} +// CHECK-FIXES: auto a8(int arg) -> C<int>; // @@ -99,63 +99,63 @@ C<int>a8(int arg); inline int d1(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto d1(int arg) -> int;{{$}} +// CHECK-FIXES: inline auto d1(int arg) -> int; extern "C" int d2(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}extern "C" auto d2(int arg) -> int;{{$}} +// CHECK-FIXES: extern "C" auto d2(int arg) -> int; inline int d3(int arg) noexcept(true); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto d3(int arg) noexcept(true) -> int;{{$}} +// CHECK-FIXES: inline auto d3(int arg) noexcept(true) -> int; inline int d4(int arg) try { return 0; } catch(...) { return 0; } // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto d4(int arg) -> int try { return 0; } catch(...) { return 0; }{{$}} +// CHECK-FIXES: inline auto d4(int arg) -> int try { return 0; } catch(...) { return 0; } int d5(int arg) throw(); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto d5(int arg) throw() -> int;{{$}} +// CHECK-FIXES: auto d5(int arg) throw() -> int; static int d6(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto d6(int arg) -> int;{{$}} +// CHECK-FIXES: static auto d6(int arg) -> int; int static d6(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto static d6(int arg) -> int;{{$}} +// CHECK-FIXES: auto static d6(int arg) -> int; unsigned static int d7(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto d7(int arg) -> unsigned int;{{$}} +// CHECK-FIXES: static auto d7(int arg) -> unsigned int; const long static int volatile constexpr unsigned inline long d8(int arg); // CHECK-MESSAGES: :[[@LINE-1]]:63: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static constexpr inline auto d8(int arg) -> const long int volatile unsigned long;{{$}} +// CHECK-FIXES: static constexpr inline auto d8(int arg) -> const long int volatile unsigned long; int constexpr d9(); // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto constexpr d9() -> int;{{$}} +// CHECK-FIXES: auto constexpr d9() -> int; inline int constexpr d10(); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto constexpr d10() -> int;{{$}} +// CHECK-FIXES: inline auto constexpr d10() -> int; unsigned constexpr int d11(); // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}constexpr auto d11() -> unsigned int;{{$}} +// CHECK-FIXES: constexpr auto d11() -> unsigned int; unsigned extern int d13(); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}extern auto d13() -> unsigned int;{{$}} +// CHECK-FIXES: extern auto d13() -> unsigned int; int static& d14(); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto d14() -> int &;{{$}} +// CHECK-FIXES: static auto d14() -> int &; class DDD { int friend unsigned m1(); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} friend auto m1() -> int unsigned;{{$}} +// CHECK-FIXES: friend auto m1() -> int unsigned; int friend unsigned m1() { return 0; } // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} friend auto m1() -> int unsigned { return 0; }{{$}} +// CHECK-FIXES: friend auto m1() -> int unsigned { return 0; } const long int friend volatile constexpr unsigned inline long m2(); // CHECK-MESSAGES: :[[@LINE-1]]:67: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} friend constexpr inline auto m2() -> const long int volatile unsigned long;{{$}} +// CHECK-FIXES: friend constexpr inline auto m2() -> const long int volatile unsigned long; int virtual unsigned m3(); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto m3() -> int unsigned;{{$}} +// CHECK-FIXES: virtual auto m3() -> int unsigned; template <typename T> int friend unsigned m4(); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} friend auto m4() -> int unsigned;{{$}} +// CHECK-FIXES: friend auto m4() -> int unsigned; }; // @@ -166,27 +166,27 @@ namespace N { int e1(); } // CHECK-MESSAGES: :[[@LINE-2]]:9: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto e1() -> int;{{$}} +// CHECK-FIXES: auto e1() -> int; int N::e1() { return 0; } // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto N::e1() -> int { return 0; }{{$}} +// CHECK-FIXES: auto N::e1() -> int { return 0; } // // Functions with unsupported return types // int (*e3())(double); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}int (*e3())(double);{{$}} +// CHECK-FIXES: int (*e3())(double); struct A; int A::* e5(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}int A::* e5();{{$}} +// CHECK-FIXES: int A::* e5(); int std::vector<std::string>::* e6(); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}int std::vector<std::string>::* e6();{{$}} +// CHECK-FIXES: int std::vector<std::string>::* e6(); int (std::vector<std::string>::*e7())(double); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}int (std::vector<std::string>::*e7())(double);{{$}} +// CHECK-FIXES: int (std::vector<std::string>::*e7())(double); // // Functions with complex return types @@ -194,31 +194,31 @@ int (std::vector<std::string>::*e7())(double); inline volatile const std::vector<std::string> e2(); // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto e2() -> volatile const std::vector<std::string>;{{$}} +// CHECK-FIXES: inline auto e2() -> volatile const std::vector<std::string>; inline const std::vector<std::string> volatile e2(); // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto e2() -> const std::vector<std::string> volatile;{{$}} +// CHECK-FIXES: inline auto e2() -> const std::vector<std::string> volatile; inline std::vector<std::string> const volatile e2(); // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}inline auto e2() -> std::vector<std::string> const volatile;{{$}} +// CHECK-FIXES: inline auto e2() -> std::vector<std::string> const volatile; int* e8(); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto e8() -> int*;{{$}} +// CHECK-FIXES: auto e8() -> int*; static const char* e9(void* user_data); // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto e9(void* user_data) -> const char*;{{$}} +// CHECK-FIXES: static auto e9(void* user_data) -> const char*; static const char* const e10(void* user_data); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto e10(void* user_data) -> const char* const;{{$}} +// CHECK-FIXES: static auto e10(void* user_data) -> const char* const; static const char** volatile * const & e11(void* user_data); // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto e11(void* user_data) -> const char** volatile * const &;{{$}} +// CHECK-FIXES: static auto e11(void* user_data) -> const char** volatile * const &; static const char* const * const * const e12(void* user_data); // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}static auto e12(void* user_data) -> const char* const * const * const;{{$}} +// CHECK-FIXES: static auto e12(void* user_data) -> const char* const * const * const; struct A e13(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto e13() -> struct A;{{$}} +// CHECK-FIXES: auto e13() -> struct A; // // deduced return types @@ -226,31 +226,31 @@ struct A e13(); const auto ded1(); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto ded1() -> const auto;{{$}} +// CHECK-FIXES: auto ded1() -> const auto; const auto& ded2(); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto ded2() -> const auto&;{{$}} +// CHECK-FIXES: auto ded2() -> const auto&; decltype(auto) ded3(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto ded3() -> decltype(auto);{{$}} +// CHECK-FIXES: auto ded3() -> decltype(auto); decltype(1 + 2) dec1() { return 1 + 2; } // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto dec1() -> decltype(1 + 2) { return 1 + 2; }{{$}} +// CHECK-FIXES: auto dec1() -> decltype(1 + 2) { return 1 + 2; } template <typename F, typename T> decltype(std::declval<F>(std::declval<T>)) dec2(F f, T t) { return f(t); } // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto dec2(F f, T t) -> decltype(std::declval<F>(std::declval<T>)) { return f(t); }{{$}} +// CHECK-FIXES: auto dec2(F f, T t) -> decltype(std::declval<F>(std::declval<T>)) { return f(t); } template <typename T> typename decltype(std::declval<T>())::value_type dec3(); // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto dec3() -> typename decltype(std::declval<T>())::value_type;{{$}} +// CHECK-FIXES: auto dec3() -> typename decltype(std::declval<T>())::value_type; template <typename T> decltype(std::declval<T>())* dec4(); // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto dec4() -> decltype(std::declval<T>())*;{{$}} +// CHECK-FIXES: auto dec4() -> decltype(std::declval<T>())*; // // Methods @@ -259,73 +259,73 @@ decltype(std::declval<T>())* dec4(); struct B { B& operator=(const B&); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto operator=(const B&) -> B&;{{$}} +// CHECK-FIXES: auto operator=(const B&) -> B&; double base1(int, bool b); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto base1(int, bool b) -> double;{{$}} +// CHECK-FIXES: auto base1(int, bool b) -> double; virtual double base2(int, bool b) { return 0; } // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto base2(int, bool b) -> double { return 0; }{{$}} +// CHECK-FIXES: virtual auto base2(int, bool b) -> double { return 0; } virtual float base3() const = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto base3() const -> float = 0;{{$}} +// CHECK-FIXES: virtual auto base3() const -> float = 0; virtual float base4() volatile = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto base4() volatile -> float = 0;{{$}} +// CHECK-FIXES: virtual auto base4() volatile -> float = 0; double base5(int, bool b) &&; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto base5(int, bool b) && -> double;{{$}} +// CHECK-FIXES: auto base5(int, bool b) && -> double; double base6(int, bool b) const &&; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto base6(int, bool b) const && -> double;{{$}} +// CHECK-FIXES: auto base6(int, bool b) const && -> double; double base7(int, bool b) const & = delete; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto base7(int, bool b) const & -> double = delete;{{$}} +// CHECK-FIXES: auto base7(int, bool b) const & -> double = delete; double base8(int, bool b) const volatile & = delete; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto base8(int, bool b) const volatile & -> double = delete;{{$}} +// CHECK-FIXES: auto base8(int, bool b) const volatile & -> double = delete; virtual const char * base9() const noexcept { return ""; } // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto base9() const noexcept -> const char * { return ""; }{{$}} +// CHECK-FIXES: virtual auto base9() const noexcept -> const char * { return ""; } }; double B::base1(int, bool b) { return 0; } // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto B::base1(int, bool b) -> double { return 0; }{{$}} +// CHECK-FIXES: auto B::base1(int, bool b) -> double { return 0; } struct D : B { virtual double f1(int, bool b) final; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto f1(int, bool b) -> double final;{{$}} +// CHECK-FIXES: virtual auto f1(int, bool b) -> double final; virtual double base2(int, bool b) override; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto base2(int, bool b) -> double override;{{$}} +// CHECK-FIXES: virtual auto base2(int, bool b) -> double override; virtual float base3() const override final { return 0; } // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} virtual auto base3() const -> float override final { return 0; }{{$}} +// CHECK-FIXES: virtual auto base3() const -> float override final { return 0; } const char * base9() const noexcept override { return ""; } // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto base9() const noexcept -> const char * override { return ""; }{{$}} +// CHECK-FIXES: auto base9() const noexcept -> const char * override { return ""; } int f2() __restrict; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto f2() __restrict -> int;{{$}} +// CHECK-FIXES: auto f2() __restrict -> int; volatile int* __restrict f3() const __restrict noexcept; // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto f3() const __restrict noexcept -> volatile int* __restrict;{{$}} +// CHECK-FIXES: auto f3() const __restrict noexcept -> volatile int* __restrict; }; // @@ -334,13 +334,13 @@ struct D : B { int g1() [[asdf]]; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto g1() -> int {{[[][[]}}asdf{{[]][]]}};{{$}} +// CHECK-FIXES: auto g1() -> int {{[[][[]}}asdf{{[]][]]}}; [[noreturn]] int g2(); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}{{[[][[]}}noreturn{{[]][]]}} auto g2() -> int;{{$}} +// CHECK-FIXES: {{[[][[]}}noreturn{{[]][]]}} auto g2() -> int; int g2 [[noreturn]] (); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto g2 {{[[][[]}}noreturn{{[]][]]}} () -> int;{{$}} +// CHECK-FIXES: auto g2 {{[[][[]}}noreturn{{[]][]]}} () -> int; int unsigned g3() __attribute__((cdecl)); // FunctionTypeLoc is null. // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a trailing return type for this function [modernize-use-trailing-return-type] int unsigned __attribute__((cdecl)) g3() ; // FunctionTypeLoc is null. @@ -354,7 +354,7 @@ __attribute__((cdecl)) int unsigned g3() ; // FunctionTypeLoc is null. template <typename Container> [[maybe_unused]] typename Container::value_type const volatile&& t1(Container& C) noexcept; // CHECK-MESSAGES: :[[@LINE-1]]:66: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}{{[[][[]}}maybe_unused{{[]][]]}} auto t1(Container& C) noexcept -> typename Container::value_type const volatile&&;{{$}} +// CHECK-FIXES: {{[[][[]}}maybe_unused{{[]][]]}} auto t1(Container& C) noexcept -> typename Container::value_type const volatile&&; template <typename T> class BB { using type = int; @@ -362,7 +362,7 @@ class BB { template <typename U> typename BB<U>::type m1(); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto m1() -> typename BB<U>::type;{{$}} +// CHECK-FIXES: auto m1() -> typename BB<U>::type; }; // @@ -372,38 +372,38 @@ class BB { #define DWORD unsigned int DWORD h1(); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h1() -> DWORD;{{$}} +// CHECK-FIXES: auto h1() -> DWORD; #define INT int #define UNSIGNED unsigned UNSIGNED INT h2(); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h2() -> UNSIGNED INT;{{$}} +// CHECK-FIXES: auto h2() -> UNSIGNED INT; #define CONST const CONST int h3(); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h3() -> CONST int;{{$}} +// CHECK-FIXES: auto h3() -> CONST int; #define ALWAYS_INLINE inline #define DLL_EXPORT __declspec(dllexport) ALWAYS_INLINE DLL_EXPORT int h4(); // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}ALWAYS_INLINE DLL_EXPORT auto h4() -> int;{{$}} +// CHECK-FIXES: ALWAYS_INLINE DLL_EXPORT auto h4() -> int; #define DEPRECATED __attribute__((deprecated)) int h5() DEPRECATED; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h5() -> int DEPRECATED;{{$}} +// CHECK-FIXES: auto h5() -> int DEPRECATED; int DEPRECATED h5(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto DEPRECATED h5() -> int;{{$}} +// CHECK-FIXES: auto DEPRECATED h5() -> int; DEPRECATED int h5(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}DEPRECATED auto h5() -> int;{{$}} +// CHECK-FIXES: DEPRECATED auto h5() -> int; [[noreturn]] [[nodiscard]] DEPRECATED DLL_EXPORT int h6 [[deprecated]] (); // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}{{[[][[]}}noreturn{{[]][]]}} {{[[][[]}}nodiscard{{[]][]]}} DEPRECATED DLL_EXPORT auto h6 {{[[][[]}}deprecated{{[]][]]}} () -> int;{{$}} +// CHECK-FIXES: {{[[][[]}}noreturn{{[]][]]}} {{[[][[]}}nodiscard{{[]][]]}} DEPRECATED DLL_EXPORT auto h6 {{[[][[]}}deprecated{{[]][]]}} () -> int; #define FUNCTION_NAME(a, b) a##b int FUNCTION_NAME(foo, bar)(); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto FUNCTION_NAME(foo, bar)() -> int;{{$}} +// CHECK-FIXES: auto FUNCTION_NAME(foo, bar)() -> int; #define DEFINE_FUNCTION_1(a, b) int a##b() DEFINE_FUNCTION_1(foo, bar); // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use a trailing return type for this function [modernize-use-trailing-return-type] @@ -422,18 +422,18 @@ using Real = T; #define PRECISION float Real<PRECISION> h8() { return 0.; } // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h8() -> Real<PRECISION> { return 0.; }{{$}} +// CHECK-FIXES: auto h8() -> Real<PRECISION> { return 0.; } #define MAYBE_UNUSED_MACRO [[maybe_unused]] template <typename Container> MAYBE_UNUSED_MACRO typename Container::value_type const volatile** const h9(Container& C) noexcept; // CHECK-MESSAGES: :[[@LINE-1]]:74: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}MAYBE_UNUSED_MACRO auto h9(Container& C) noexcept -> typename Container::value_type const volatile** const;{{$}} +// CHECK-FIXES: MAYBE_UNUSED_MACRO auto h9(Container& C) noexcept -> typename Container::value_type const volatile** const; #define NOEXCEPT noexcept int h9(int arg) NOEXCEPT; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h9(int arg) NOEXCEPT -> int;{{$}} +// CHECK-FIXES: auto h9(int arg) NOEXCEPT -> int; #define STATIC_INT static int STATIC_INT h10(); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] @@ -443,20 +443,20 @@ UNSIGNED_STATIC_INT h11(); #define STATIC static unsigned STATIC int h11(); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}STATIC auto h11() -> unsigned int;{{$}} +// CHECK-FIXES: STATIC auto h11() -> unsigned int; #define STATIC_CONSTEXPR static constexpr unsigned STATIC_CONSTEXPR int h12(); // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}STATIC_CONSTEXPR auto h12() -> unsigned int;{{$}} +// CHECK-FIXES: STATIC_CONSTEXPR auto h12() -> unsigned int; #define STATIC_CONSTEXPR_LONG static constexpr long unsigned STATIC_CONSTEXPR_LONG int h13(); // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: use a trailing return type for this function [modernize-use-trailing-return-type] DEPRECATED const int& h14(); // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}DEPRECATED auto h14() -> const int&;{{$}} +// CHECK-FIXES: DEPRECATED auto h14() -> const int&; DEPRECATED const long static volatile unsigned& h15(); // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}DEPRECATED static auto h15() -> const long volatile unsigned&;{{$}} +// CHECK-FIXES: DEPRECATED static auto h15() -> const long volatile unsigned&; #define WRAP(x) x WRAP(const) int& h16(); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use a trailing return type for this function [modernize-use-trailing-return-type] @@ -467,25 +467,25 @@ CONCAT(con, st) int& h16(); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: use a trailing return type for this function [modernize-use-trailing-return-type] DEPRECATED const UNSIGNED& h17(); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}DEPRECATED auto h17() -> const UNSIGNED&;{{$}} +// CHECK-FIXES: DEPRECATED auto h17() -> const UNSIGNED&; DEPRECATED CONST UNSIGNED STATIC& h18(); // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}DEPRECATED STATIC auto h18() -> CONST UNSIGNED &;{{$}} +// CHECK-FIXES: DEPRECATED STATIC auto h18() -> CONST UNSIGNED &; #define CONST_CAT con##st CONST_CAT int& h19(); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h19() -> CONST_CAT int&;{{$}} +// CHECK-FIXES: auto h19() -> CONST_CAT int&; #define CONST_F_MACRO WRAP(CONST_CAT) CONST_F_MACRO int& h19(); // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h19() -> CONST_F_MACRO int&;{{$}} +// CHECK-FIXES: auto h19() -> CONST_F_MACRO int&; // Macro COMMAND_LINE_INT is defined on the command line via: -DCOMMAND_LINE_INT=int const COMMAND_LINE_INT& h20(); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h20() -> const COMMAND_LINE_INT&;{{$}} +// CHECK-FIXES: auto h20() -> const COMMAND_LINE_INT&; decltype(COMMAND_LINE_INT{}) h21(); // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto h21() -> decltype(COMMAND_LINE_INT{});{{$}} +// CHECK-FIXES: auto h21() -> decltype(COMMAND_LINE_INT{}); // // Name collisions @@ -494,67 +494,67 @@ struct Object { long long value; }; Object j1(unsigned Object) { return {Object * 2}; } // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}Object j1(unsigned Object) { return {Object * 2}; }{{$}} +// CHECK-FIXES: Object j1(unsigned Object) { return {Object * 2}; } ::Object j1(unsigned Object); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto j1(unsigned Object) -> ::Object;{{$}} +// CHECK-FIXES: auto j1(unsigned Object) -> ::Object; const Object& j2(unsigned a, int b, char Object, long l); // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}const Object& j2(unsigned a, int b, char Object, long l);{{$}} +// CHECK-FIXES: const Object& j2(unsigned a, int b, char Object, long l); const struct Object& j2(unsigned a, int b, char Object, long l); // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto j2(unsigned a, int b, char Object, long l) -> const struct Object&;{{$}} +// CHECK-FIXES: auto j2(unsigned a, int b, char Object, long l) -> const struct Object&; std::vector<Object> j3(unsigned Object); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}std::vector<Object> j3(unsigned Object);{{$}} +// CHECK-FIXES: std::vector<Object> j3(unsigned Object); std::vector<const Object> j7(unsigned Object); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}std::vector<const Object> j7(unsigned Object);{{$}} +// CHECK-FIXES: std::vector<const Object> j7(unsigned Object); std::vector<Object> j4(unsigned vector); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto j4(unsigned vector) -> std::vector<Object>;{{$}} +// CHECK-FIXES: auto j4(unsigned vector) -> std::vector<Object>; std::vector<::Object> j4(unsigned vector); // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto j4(unsigned vector) -> std::vector<::Object>;{{$}} +// CHECK-FIXES: auto j4(unsigned vector) -> std::vector<::Object>; std::vector<struct Object> j4(unsigned vector); // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto j4(unsigned vector) -> std::vector<struct Object>;{{$}} +// CHECK-FIXES: auto j4(unsigned vector) -> std::vector<struct Object>; std::vector<Object> j4(unsigned Vector); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto j4(unsigned Vector) -> std::vector<Object>;{{$}} +// CHECK-FIXES: auto j4(unsigned Vector) -> std::vector<Object>; using std::vector; vector<Object> j5(unsigned vector); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}vector<Object> j5(unsigned vector);{{$}} +// CHECK-FIXES: vector<Object> j5(unsigned vector); constexpr auto Size = 5; std::array<int, Size> j6(unsigned Size); // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}std::array<int, Size> j6(unsigned Size);{{$}} +// CHECK-FIXES: std::array<int, Size> j6(unsigned Size); std::array<decltype(Size), (Size * 2) + 1> j8(unsigned Size); // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}std::array<decltype(Size), (Size * 2) + 1> j8(unsigned Size);{{$}} +// CHECK-FIXES: std::array<decltype(Size), (Size * 2) + 1> j8(unsigned Size); using std::ostream; std::tuple<int, std::string, ostream>& operator<<(ostream& ostream, float i); // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}std::tuple<int, std::string, ostream>& operator<<(ostream& ostream, float i);{{$}} +// CHECK-FIXES: std::tuple<int, std::string, ostream>& operator<<(ostream& ostream, float i); class CC { int Object; struct Object m(); // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto m() -> struct Object;{{$}} +// CHECK-FIXES: auto m() -> struct Object; }; Object CC::m() { return {0}; } // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto CC::m() -> Object { return {0}; }{{$}} +// CHECK-FIXES: auto CC::m() -> Object { return {0}; } class DD : public CC { ::Object g(); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}} auto g() -> ::Object;{{$}} +// CHECK-FIXES: auto g() -> ::Object; }; Object DD::g() { // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}auto DD::g() -> Object {{{$}} +// CHECK-FIXES: auto DD::g() -> Object { return {0}; } @@ -564,7 +564,7 @@ Object DD::g() { ostream& operator<<(ostream& ostream, int i); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return-type] -// CHECK-FIXES: {{^}}ostream& operator<<(ostream& ostream, int i);{{$}} +// CHECK-FIXES: ostream& operator<<(ostream& ostream, int i); // // Samples which do not trigger the check diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/duplicate-include/duplicate-include.h b/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/duplicate-include/duplicate-include.h index 22d3a3a..739c81e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/duplicate-include/duplicate-include.h +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/duplicate-include/duplicate-include.h @@ -7,9 +7,9 @@ extern int h; #include "duplicate-include2.h" extern int i; // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: duplicate include -// CHECK-FIXES: {{^extern int g;$}} -// CHECK-FIXES-NEXT: {{^#include "duplicate-include2.h"$}} -// CHECK-FIXES-NEXT: {{^extern int h;$}} -// CHECK-FIXES-NEXT: {{^extern int i;$}} +// CHECK-FIXES: extern int g; +// CHECK-FIXES-NEXT: #include "duplicate-include2.h" +// CHECK-FIXES-NEXT: extern int h; +// CHECK-FIXES-NEXT: extern int i; #endif diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/container-data-pointer.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/container-data-pointer.cpp index 7d8500e..a8e0eb6 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/container-data-pointer.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/container-data-pointer.cpp @@ -46,20 +46,20 @@ void g(size_t s) { std::vector<unsigned char> b(s); f(&((b)[(z)])); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}f(b.data());{{$}} + // CHECK-FIXES: f(b.data()); } void h() { std::string s; f(&((s).operator[]((z)))); // CHECK-MESSAGES-CLASSIC: :[[@LINE-1]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES-CLASSIC: {{^ }}f(s.data());{{$}} + // CHECK-FIXES-CLASSIC: f(s.data()); // CHECK-MESSAGES-WITH-CONFIG-NOT: :[[@LINE-3]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] std::wstring w; f(&((&(w))->operator[]((z)))); // CHECK-MESSAGES-CLASSIC: :[[@LINE-1]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES-CLASSIC: {{^ }}f(w.data());{{$}} + // CHECK-FIXES-CLASSIC: f(w.data()); // CHECK-MESSAGES-WITH-CONFIG-NOT: :[[@LINE-3]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] } @@ -69,7 +69,7 @@ void i(U s) { std::vector<T> b(s); f(&b[0]); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}f(b.data());{{$}} + // CHECK-FIXES: f(b.data()); } template void i<unsigned char, size_t>(size_t); @@ -77,13 +77,13 @@ template void i<unsigned char, size_t>(size_t); void j(std::vector<unsigned char> * const v) { f(&(*v)[0]); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}f(v->data());{{$}} + // CHECK-FIXES: f(v->data()); } void k(const std::vector<unsigned char> &v) { f(&v[0]); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}f(v.data());{{$}} + // CHECK-FIXES: f(v.data()); } void l() { @@ -96,7 +96,7 @@ template <typename T> void m(const std::vector<T> &v) { return &v[0]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}return v.data();{{$}} + // CHECK-FIXES: return v.data(); } template <typename T> @@ -115,7 +115,7 @@ const T *n(const container_without_data<T> &c) { const int *o(const std::vector<std::vector<std::vector<int>>> &v, const size_t idx1, const size_t idx2) { return &v[idx1][idx2][0]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}return v[idx1][idx2].data();{{$}} + // CHECK-FIXES: return v[idx1][idx2].data(); } std::vector<int> &select(std::vector<int> &u, std::vector<int> &v) { @@ -125,13 +125,13 @@ std::vector<int> &select(std::vector<int> &u, std::vector<int> &v) { int *p(std::vector<int> &v1, std::vector<int> &v2) { return &select(*&v1, v2)[0]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}return select(*&v1, v2).data();{{$}} + // CHECK-FIXES: return select(*&v1, v2).data(); } int *q(std::vector<int> ***v) { return &(***v)[0]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}return (**v)->data();{{$}} + // CHECK-FIXES: return (**v)->data(); } struct VectorHolder { @@ -142,5 +142,5 @@ int *r() { VectorHolder holder; return &holder.v[0]; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'data' should be used for accessing the data pointer instead of taking the address of the 0-th element [readability-container-data-pointer] - // CHECK-FIXES: {{^ }}return holder.v.data();{{$}} + // CHECK-FIXES: return holder.v.data(); } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty-cxx20.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty-cxx20.cpp index 40717de..42fb927d 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty-cxx20.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty-cxx20.cpp @@ -34,11 +34,11 @@ void returnsVoid() { if (OEO != OpEqOnly<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness - // CHECK-FIXES: {{^ }}if (!OEO.empty()){{$}} + // CHECK-FIXES: if (!OEO.empty()) // CHECK-MESSAGES: :19:8: note: method 'OpEqOnly'::empty() defined here if (HSM != HasSpaceshipMem<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness - // CHECK-FIXES: {{^ }}if (!HSM.empty()){{$}} + // CHECK-FIXES: if (!HSM.empty()) // CHECK-MESSAGES: :27:8: note: method 'HasSpaceshipMem'::empty() defined here } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty.cpp index 6a67310..8950c72 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/container-size-empty.cpp @@ -119,110 +119,110 @@ bool returnsBool() { if (intSet.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (intSet.empty()){{$}} + // CHECK-FIXES: if (intSet.empty()) // CHECK-MESSAGES: :21:8: note: method 'set'::empty() defined here if (intSet == std::set<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness - // CHECK-FIXES: {{^ }}if (intSet.empty()){{$}} + // CHECK-FIXES: if (intSet.empty()) // CHECK-MESSAGES: :21:8: note: method 'set'::empty() defined here if (s_func() == "") ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (s_func().empty()){{$}} + // CHECK-FIXES: if (s_func().empty()) if (str.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' - // CHECK-FIXES: {{^ }}if (str.empty()){{$}} + // CHECK-FIXES: if (str.empty()) if (str.length() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'length' - // CHECK-FIXES: {{^ }}if (str.empty()){{$}} + // CHECK-FIXES: if (str.empty()) if ((str + str2).size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' - // CHECK-FIXES: {{^ }}if ((str + str2).empty()){{$}} + // CHECK-FIXES: if ((str + str2).empty()) if ((str + str2).length() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'length' - // CHECK-FIXES: {{^ }}if ((str + str2).empty()){{$}} + // CHECK-FIXES: if ((str + str2).empty()) if (str == "") ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (str.empty()){{$}} + // CHECK-FIXES: if (str.empty()) if (str + str2 == "") ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if ((str + str2).empty()){{$}} + // CHECK-FIXES: if ((str + str2).empty()) if (wstr.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' - // CHECK-FIXES: {{^ }}if (wstr.empty()){{$}} + // CHECK-FIXES: if (wstr.empty()) if (wstr.length() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'length' - // CHECK-FIXES: {{^ }}if (wstr.empty()){{$}} + // CHECK-FIXES: if (wstr.empty()) if (wstr == L"") ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (wstr.empty()){{$}} + // CHECK-FIXES: if (wstr.empty()) std::vector<int> vect; if (vect.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (vect == std::vector<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (vect.size() != 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (vect != std::vector<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (0 == vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (0 != vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (std::vector<int>() == vect) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (std::vector<int>() != vect) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (vect.size() > 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (0 < vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (vect.size() < 1) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (1 > vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (vect.size() >= 1) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (1 <= vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (vect.size() > 1) // no warning ; if (1 < vect.size()) // no warning @@ -234,11 +234,11 @@ bool returnsBool() { if (!vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect.empty()){{$}} + // CHECK-FIXES: if (vect.empty()) if (vect.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect.empty()){{$}} + // CHECK-FIXES: if (!vect.empty()) if (vect.empty()) ; @@ -247,25 +247,25 @@ bool returnsBool() { if (vect2.size() != 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!vect2.empty()){{$}} + // CHECK-FIXES: if (!vect2.empty()) std::vector<int> *vect3 = new std::vector<int>(); if (vect3->size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect3->empty()){{$}} + // CHECK-FIXES: if (vect3->empty()) if ((*vect3).size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if ((*vect3).empty()){{$}} + // CHECK-FIXES: if ((*vect3).empty()) if ((*vect3) == std::vector<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect3->empty()){{$}} + // CHECK-FIXES: if (vect3->empty()) if (*vect3 == std::vector<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect3->empty()){{$}} + // CHECK-FIXES: if (vect3->empty()) delete vect3; @@ -273,69 +273,69 @@ bool returnsBool() { if (vect4.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect4.empty()){{$}} + // CHECK-FIXES: if (vect4.empty()) if (vect4 == std::vector<int>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (vect4.empty()){{$}} + // CHECK-FIXES: if (vect4.empty()) TemplatedContainer<void> templated_container; if (templated_container.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (templated_container == TemplatedContainer<void>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (templated_container.size() != 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container != TemplatedContainer<void>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (0 == templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (TemplatedContainer<void>() == templated_container) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (0 != templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (TemplatedContainer<void>() != templated_container) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container.size() > 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (0 < templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container.size() < 1) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (1 > templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (templated_container.size() >= 1) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (1 <= templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container.size() > 1) // no warning ; if (1 < templated_container.size()) // no warning @@ -347,11 +347,11 @@ bool returnsBool() { if (!templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) if (templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container.empty()) ; @@ -411,47 +411,47 @@ bool returnsBool() { if (derived.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (derived.empty()){{$}} + // CHECK-FIXES: if (derived.empty()) if (derived == Derived()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (derived.empty()){{$}} + // CHECK-FIXES: if (derived.empty()) takesBool(derived.size()); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}takesBool(!derived.empty()); + // CHECK-FIXES: takesBool(!derived.empty()); takesBool(derived.size() == 0); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}takesBool(derived.empty()); + // CHECK-FIXES: takesBool(derived.empty()); takesBool(derived.size() != 0); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}takesBool(!derived.empty()); + // CHECK-FIXES: takesBool(!derived.empty()); bool b1 = derived.size(); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}bool b1 = !derived.empty(); + // CHECK-FIXES: bool b1 = !derived.empty(); bool b2(derived.size()); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}bool b2(!derived.empty()); + // CHECK-FIXES: bool b2(!derived.empty()); auto b3 = static_cast<bool>(derived.size()); // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}auto b3 = static_cast<bool>(!derived.empty()); + // CHECK-FIXES: auto b3 = static_cast<bool>(!derived.empty()); auto b4 = (bool)derived.size(); // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}auto b4 = (bool)!derived.empty(); + // CHECK-FIXES: auto b4 = (bool)!derived.empty(); auto b5 = bool(derived.size()); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}auto b5 = bool(!derived.empty()); + // CHECK-FIXES: auto b5 = bool(!derived.empty()); return derived.size(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}return !derived.empty(); + // CHECK-FIXES: return !derived.empty(); } class ConstructWithBoolField { @@ -460,7 +460,7 @@ public: ConstructWithBoolField(const std::vector<int> &C) : B(C.size()) {} // CHECK-MESSAGES: :[[@LINE-1]]:57: warning: the 'empty' method should be used // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here -// CHECK-FIXES: {{^ }}ConstructWithBoolField(const std::vector<int> &C) : B(!C.empty()) {} +// CHECK-FIXES: ConstructWithBoolField(const std::vector<int> &C) : B(!C.empty()) {} }; struct StructWithNSDMI { @@ -468,21 +468,21 @@ struct StructWithNSDMI { bool B = C.size(); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: the 'empty' method should be used // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here -// CHECK-FIXES: {{^ }}bool B = !C.empty(); +// CHECK-FIXES: bool B = !C.empty(); }; int func(const std::vector<int> &C) { return C.size() ? 0 : 1; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here -// CHECK-FIXES: {{^ }}return !C.empty() ? 0 : 1; +// CHECK-FIXES: return !C.empty() ? 0 : 1; } constexpr Lazy L; static_assert(!L.size(), ""); // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: the 'empty' method should be used // CHECK-MESSAGES: :94:18: note: method 'Lazy'::empty() defined here -// CHECK-FIXES: {{^}}static_assert(L.empty(), ""); +// CHECK-FIXES: static_assert(L.empty(), ""); struct StructWithLazyNoexcept { void func() noexcept(L.size()); @@ -497,11 +497,11 @@ template <typename T> void f() { ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (!v.empty()){{$}} + // CHECK-FIXES: if (!v.empty()) if (v == std::vector<T>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of comparing to an empty object [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (v.empty()){{$}} + // CHECK-FIXES: if (v.empty()) // CHECK-FIXES-NEXT: ; CHECKSIZE(v); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used @@ -513,12 +513,12 @@ template <typename T> void f() { ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container != TemplatedContainer<T>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) // CHECK-FIXES-NEXT: ; CHECKSIZE(templated_container); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used @@ -529,12 +529,12 @@ template <typename T> void f() { ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: string:{{[0-9]+}}:8: note: method 'basic_string'::empty() defined here - // CHECK-FIXES: {{^ }}if (!s.empty()){{$}} + // CHECK-FIXES: if (!s.empty()) if (s.length()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'length' [readability-container-size-empty] // CHECK-MESSAGES: string:{{[0-9]+}}:8: note: method 'basic_string'::empty() defined here - // CHECK-FIXES: {{^ }}if (!s.empty()){{$}} + // CHECK-FIXES: if (!s.empty()) } void g() { @@ -550,33 +550,33 @@ bool neverInstantiatedTemplate() { ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (!v.empty()){{$}} + // CHECK-FIXES: if (!v.empty()) if (v == std::vector<T>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of comparing to an empty object [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (v.empty()){{$}} + // CHECK-FIXES: if (v.empty()) // CHECK-FIXES-NEXT: ; if (v.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (v.empty()){{$}} + // CHECK-FIXES: if (v.empty()) if (v.size() != 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (!v.empty()){{$}} + // CHECK-FIXES: if (!v.empty()) if (v.size() < 1) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (v.empty()){{$}} + // CHECK-FIXES: if (v.empty()) if (v.size() > 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (!v.empty()){{$}} + // CHECK-FIXES: if (!v.empty()) if (v.size() == 1) ; if (v.size() != 1) @@ -590,91 +590,91 @@ bool neverInstantiatedTemplate() { ; // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (static_cast<bool>(!v.empty())){{$}} + // CHECK-FIXES: if (static_cast<bool>(!v.empty())) if (v.size() && false) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (!v.empty() && false){{$}} + // CHECK-FIXES: if (!v.empty() && false) if (!v.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}if (v.empty()){{$}} + // CHECK-FIXES: if (v.empty()) TemplatedContainer<T> templated_container; if (templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) if (templated_container != TemplatedContainer<T>()) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}} + // CHECK-FIXES: if (!templated_container.empty()) // CHECK-FIXES-NEXT: ; while (templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}while (!templated_container.empty()){{$}} + // CHECK-FIXES: while (!templated_container.empty()) do { } while (templated_container.size()); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}while (!templated_container.empty()); + // CHECK-FIXES: while (!templated_container.empty()); for (; templated_container.size();) ; // CHECK-MESSAGES: :[[@LINE-2]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}for (; !templated_container.empty();){{$}} + // CHECK-FIXES: for (; !templated_container.empty();) if (true && templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:15: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (true && !templated_container.empty()){{$}} + // CHECK-FIXES: if (true && !templated_container.empty()) if (true || templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:15: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (true || !templated_container.empty()){{$}} + // CHECK-FIXES: if (true || !templated_container.empty()) if (!templated_container.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}} + // CHECK-FIXES: if (templated_container.empty()) bool b1 = templated_container.size(); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}bool b1 = !templated_container.empty(); + // CHECK-FIXES: bool b1 = !templated_container.empty(); bool b2(templated_container.size()); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}bool b2(!templated_container.empty()); + // CHECK-FIXES: bool b2(!templated_container.empty()); auto b3 = static_cast<bool>(templated_container.size()); // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}auto b3 = static_cast<bool>(!templated_container.empty()); + // CHECK-FIXES: auto b3 = static_cast<bool>(!templated_container.empty()); auto b4 = (bool)templated_container.size(); // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}auto b4 = (bool)!templated_container.empty(); + // CHECK-FIXES: auto b4 = (bool)!templated_container.empty(); auto b5 = bool(templated_container.size()); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}auto b5 = bool(!templated_container.empty()); + // CHECK-FIXES: auto b5 = bool(!templated_container.empty()); takesBool(templated_container.size()); // We don't detect this one because we don't know the parameter of takesBool @@ -683,7 +683,7 @@ bool neverInstantiatedTemplate() { return templated_container.size(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :37:8: note: method 'TemplatedContainer'::empty() defined here - // CHECK-FIXES: {{^ }}return !templated_container.empty(); + // CHECK-FIXES: return !templated_container.empty(); } template <typename TypeRequiresSize> @@ -729,14 +729,14 @@ bool call_through_unique_ptr(const std::unique_ptr<std::vector<int>> &ptr) { return ptr->size() > 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}return !ptr->empty(); + // CHECK-FIXES: return !ptr->empty(); } bool call_through_unique_ptr_deref(const std::unique_ptr<std::vector<int>> &ptr) { return (*ptr).size() > 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used // CHECK-MESSAGES: :12:8: note: method 'vector'::empty() defined here - // CHECK-FIXES: {{^ }}return !(*ptr).empty(); + // CHECK-FIXES: return !(*ptr).empty(); } struct TypedefSize { @@ -750,7 +750,7 @@ void testTypedefSize() { if (ts.size() == 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}if (ts.empty()){{$}} + // CHECK-FIXES: if (ts.empty()) } namespace std { @@ -783,7 +783,7 @@ typedef std::array<int, 10U> Array; bool testArraySize(const Array& value) { return value.size() == 0U; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] -// CHECK-FIXES: {{^ }}return value.empty();{{$}} +// CHECK-FIXES: return value.empty(); // CHECK-MESSAGES: :[[@LINE-25]]:8: note: method 'array'::empty() defined here } @@ -794,7 +794,7 @@ bool testArrayCompareToEmpty(const Array& value) { bool testDummyType(const DummyType& value) { return value == DummyType(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used to check for emptiness instead of comparing to an empty object [readability-container-size-empty] -// CHECK-FIXES: {{^ }}return value.empty();{{$}} +// CHECK-FIXES: return value.empty(); // CHECK-MESSAGES: :[[@LINE-26]]:8: note: method 'DummyType'::empty() defined here } @@ -807,7 +807,7 @@ bool testStringLiterals(const std::string& s) using namespace std::string_literals; return s == ""s; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used - // CHECK-FIXES: {{^ }}return s.empty() + // CHECK-FIXES: return s.empty() } bool testNotEmptyStringLiterals(const std::string& s) @@ -835,19 +835,19 @@ namespace PR72619 { if (s.size() < 1) ; // CHECK-MESSAGES: :[[@LINE-2]]:9: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (s.empty()){{$}} + // CHECK-FIXES: if (s.empty()) if (1 > s.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:13: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (s.empty()){{$}} + // CHECK-FIXES: if (s.empty()) if (s.size() <= 0) ; // CHECK-MESSAGES: :[[@LINE-2]]:9: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (s.empty()){{$}} + // CHECK-FIXES: if (s.empty()) if (0 >= s.size()) ; // CHECK-MESSAGES: :[[@LINE-2]]:14: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (s.empty()){{$}} + // CHECK-FIXES: if (s.empty()) } void f(const SS& s) { @@ -879,14 +879,14 @@ namespace PR88203 { if (0 == s.length(1)) {} if (0 == s.size()) {} // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (s.empty()) {}{{$}} + // CHECK-FIXES: if (s.empty()) {} } void f(const SU& s) { if (0 == s.size(1)) {} if (0 == s.length()) {} // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: the 'empty' method should be used to check for emptiness instead of 'length' [readability-container-size-empty] - // CHECK-FIXES: {{^ }}if (s.empty()) {}{{$}} + // CHECK-FIXES: if (s.empty()) {} } } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/convert-member-functions-to-static.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/convert-member-functions-to-static.cpp index a6b95bd..f933038 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/convert-member-functions-to-static.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/convert-member-functions-to-static.cpp @@ -14,7 +14,7 @@ class A { void no_use() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'no_use' can be made static - // CHECK-FIXES: {{^}} static void no_use() { + // CHECK-FIXES: static void no_use() { int i = 1; } @@ -30,25 +30,25 @@ class A { int call_static_member() { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'call_static_member' can be made static - // CHECK-FIXES: {{^}} static int call_static_member() { + // CHECK-FIXES: static int call_static_member() { already_static(); return 0; } int read_static() { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_static' can be made static - // CHECK-FIXES: {{^}} static int read_static() { + // CHECK-FIXES: static int read_static() { return static_field; } void write_static() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'write_static' can be made static - // CHECK-FIXES: {{^}} static void write_static() { + // CHECK-FIXES: static void write_static() { static_field = 1; } void static_nested() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'static_nested' can be made static - // CHECK-FIXES: {{^}} static void static_nested() { + // CHECK-FIXES: static void static_nested() { struct Nested { int Foo; int getFoo() { return Foo; } @@ -70,29 +70,29 @@ class A { int already_const_convert_to_static() const { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'already_const_convert_to_static' can be made static - // CHECK-FIXES: {{^}} static int already_const_convert_to_static() { + // CHECK-FIXES: static int already_const_convert_to_static() { return static_field; } static int out_of_line_already_static(); void out_of_line_call_static(); - // CHECK-FIXES: {{^}} static void out_of_line_call_static(); + // CHECK-FIXES: static void out_of_line_call_static(); int out_of_line_const_to_static() const; - // CHECK-FIXES: {{^}} static int out_of_line_const_to_static() ; + // CHECK-FIXES: static int out_of_line_const_to_static() ; }; int A::out_of_line_already_static() { return 0; } void A::out_of_line_call_static() { // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: method 'out_of_line_call_static' can be made static - // CHECK-FIXES: {{^}}void A::out_of_line_call_static() { + // CHECK-FIXES: void A::out_of_line_call_static() { already_static(); } int A::out_of_line_const_to_static() const { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'out_of_line_const_to_static' can be made static - // CHECK-FIXES: {{^}}int A::out_of_line_const_to_static() { + // CHECK-FIXES: int A::out_of_line_const_to_static() { return 0; } @@ -159,7 +159,7 @@ void instantiate() { struct Trailing { auto g() const -> int { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'g' can be made static - // CHECK-FIXES: {{^}} static auto g() -> int { + // CHECK-FIXES: static auto g() -> int { return 0; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/duplicate-include.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/duplicate-include.cpp index 2119602..223f077 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/duplicate-include.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/duplicate-include.cpp @@ -6,10 +6,10 @@ int b; #include <string.h> int c; // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: duplicate include [readability-duplicate-include] -// CHECK-FIXES: {{^int a;$}} -// CHECK-FIXES-NEXT: {{^#include <string.h>$}} -// CHECK-FIXES-NEXT: {{^int b;$}} -// CHECK-FIXES-NEXT: {{^int c;$}} +// CHECK-FIXES: int a; +// CHECK-FIXES-NEXT: #include <string.h> +// CHECK-FIXES-NEXT: int b; +// CHECK-FIXES-NEXT: int c; int d; #include <iostream> @@ -17,10 +17,10 @@ int e; #include <iostream> // extra stuff that will also be removed int f; // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: duplicate include -// CHECK-FIXES: {{^int d;$}} -// CHECK-FIXES-NEXT: {{^#include <iostream>$}} -// CHECK-FIXES-NEXT: {{^int e;$}} -// CHECK-FIXES-NEXT: {{^int f;$}} +// CHECK-FIXES: int d; +// CHECK-FIXES-NEXT: #include <iostream> +// CHECK-FIXES-NEXT: int e; +// CHECK-FIXES-NEXT: int f; int g; #include "duplicate-include.h" @@ -28,10 +28,10 @@ int h; #include "duplicate-include.h" int i; // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: duplicate include -// CHECK-FIXES: {{^int g;$}} -// CHECK-FIXES-NEXT: {{^#include "duplicate-include.h"$}} -// CHECK-FIXES-NEXT: {{^int h;$}} -// CHECK-FIXES-NEXT: {{^int i;$}} +// CHECK-FIXES: int g; +// CHECK-FIXES-NEXT: #include "duplicate-include.h" +// CHECK-FIXES-NEXT: int h; +// CHECK-FIXES-NEXT: int i; #include <types.h> @@ -41,35 +41,35 @@ int k; #include <sys/types.h> int l; // CHECK-MESSAGES: :[[@LINE-2]]:1: warning: duplicate include -// CHECK-FIXES: {{^int j;$}} -// CHECK-FIXES-NEXT: {{^#include <sys/types.h>$}} -// CHECK-FIXES-NEXT: {{^int k;$}} -// CHECK-FIXES-NEXT: {{^int l;$}} +// CHECK-FIXES: int j; +// CHECK-FIXES-NEXT: #include <sys/types.h> +// CHECK-FIXES-NEXT: int k; +// CHECK-FIXES-NEXT: int l; int m; # include <string.h> // lots of space int n; // CHECK-MESSAGES: :[[@LINE-2]]:9: warning: duplicate include -// CHECK-FIXES: {{^int m;$}} -// CHECK-FIXES-NEXT: {{^int n;$}} +// CHECK-FIXES: int m; +// CHECK-FIXES-NEXT: int n; // defining a macro in the main file resets the included file cache #define ARBITRARY_MACRO int o; #include <sys/types.h> int p; -// CHECK-FIXES: {{^int o;$}} -// CHECK-FIXES-NEXT: {{^#include <sys/types.h>$}} -// CHECK-FIXES-NEXT: {{^int p;$}} +// CHECK-FIXES: int o; +// CHECK-FIXES-NEXT: #include <sys/types.h> +// CHECK-FIXES-NEXT: int p; // undefining a macro resets the cache #undef ARBITRARY_MACRO int q; #include <sys/types.h> int r; -// CHECK-FIXES: {{^int q;$}} -// CHECK-FIXES-NEXT: {{^#include <sys/types.h>$}} -// CHECK-FIXES-NEXT: {{^int r;$}} +// CHECK-FIXES: int q; +// CHECK-FIXES-NEXT: #include <sys/types.h> +// CHECK-FIXES-NEXT: int r; namespace Issue_87303 { #define RESET_INCLUDE_CACHE diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-anon-record-fields.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-anon-record-fields.cpp index 1b4d4e9..16efe3f 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-anon-record-fields.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-anon-record-fields.cpp @@ -36,19 +36,19 @@ static union { int global; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'global' -// CHECK-FIXES: {{^}} int g_global;{{$}} +// CHECK-FIXES: int g_global; const int global_const; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global constant 'global_const' -// CHECK-FIXES: {{^}} const int GLOBAL_CONST;{{$}} +// CHECK-FIXES: const int GLOBAL_CONST; int *global_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'global_ptr' -// CHECK-FIXES: {{^}} int *GlobalPtr_Ptr;{{$}} +// CHECK-FIXES: int *GlobalPtr_Ptr; int *const global_const_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global constant pointer 'global_const_ptr' -// CHECK-FIXES: {{^}} int *const GLOBAL_CONST_PTR_Ptr;{{$}} +// CHECK-FIXES: int *const GLOBAL_CONST_PTR_Ptr; }; namespace ns { @@ -56,19 +56,19 @@ namespace ns { static union { int ns_global; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ns_global' -// CHECK-FIXES: {{^}} int g_ns_global;{{$}} +// CHECK-FIXES: int g_ns_global; const int ns_global_const; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global constant 'ns_global_const' -// CHECK-FIXES: {{^}} const int NS_GLOBAL_CONST;{{$}} +// CHECK-FIXES: const int NS_GLOBAL_CONST; int *ns_global_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'ns_global_ptr' -// CHECK-FIXES: {{^}} int *NsGlobalPtr_Ptr;{{$}} +// CHECK-FIXES: int *NsGlobalPtr_Ptr; int *const ns_global_const_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global constant pointer 'ns_global_const_ptr' -// CHECK-FIXES: {{^}} int *const NS_GLOBAL_CONST_PTR_Ptr;{{$}} +// CHECK-FIXES: int *const NS_GLOBAL_CONST_PTR_Ptr; }; namespace { @@ -76,19 +76,19 @@ namespace { union { int anon_ns_global; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'anon_ns_global' -// CHECK-FIXES: {{^}} int g_anon_ns_global;{{$}} +// CHECK-FIXES: int g_anon_ns_global; const int anon_ns_global_const; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global constant 'anon_ns_global_const' -// CHECK-FIXES: {{^}} const int ANON_NS_GLOBAL_CONST;{{$}} +// CHECK-FIXES: const int ANON_NS_GLOBAL_CONST; int *anon_ns_global_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'anon_ns_global_ptr' -// CHECK-FIXES: {{^}} int *AnonNsGlobalPtr_Ptr;{{$}} +// CHECK-FIXES: int *AnonNsGlobalPtr_Ptr; int *const anon_ns_global_const_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global constant pointer 'anon_ns_global_const_ptr' -// CHECK-FIXES: {{^}} int *const ANON_NS_GLOBAL_CONST_PTR_Ptr;{{$}} +// CHECK-FIXES: int *const ANON_NS_GLOBAL_CONST_PTR_Ptr; }; } @@ -101,32 +101,32 @@ public: union { int PubMember; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for public member 'PubMember' -// CHECK-FIXES: {{^}} int pub_member;{{$}} +// CHECK-FIXES: int pub_member; const int PubConstMember; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constant member 'PubConstMember' -// CHECK-FIXES: {{^}} const int pub_const_member;{{$}} +// CHECK-FIXES: const int pub_const_member; int *PubPtrMember; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for public member 'PubPtrMember' -// CHECK-FIXES: {{^}} int *pub_ptr_member;{{$}} +// CHECK-FIXES: int *pub_ptr_member; int *const PubConstPtrMember; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for constant member 'PubConstPtrMember' -// CHECK-FIXES: {{^}} int *const pub_const_ptr_member;{{$}} +// CHECK-FIXES: int *const pub_const_ptr_member; }; protected: union { int prot_member; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for protected member 'prot_member' -// CHECK-FIXES: {{^}} int _prot_member;{{$}} +// CHECK-FIXES: int _prot_member; const int prot_const_member; int *prot_ptr_member; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for protected member 'prot_ptr_member' -// CHECK-FIXES: {{^}} int *_prot_ptr_member;{{$}} +// CHECK-FIXES: int *_prot_ptr_member; int *const prot_const_ptr_member; }; @@ -136,13 +136,13 @@ private: union { int pri_member; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'pri_member' -// CHECK-FIXES: {{^}} int __pri_member;{{$}} +// CHECK-FIXES: int __pri_member; const int pri_const_member; int *pri_ptr_member; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for private member 'pri_ptr_member' -// CHECK-FIXES: {{^}} int *__pri_ptr_member;{{$}} +// CHECK-FIXES: int *__pri_ptr_member; int *const pri_const_ptr_member; }; @@ -154,32 +154,32 @@ void test() { const int local_const; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for local constant 'local_const' -// CHECK-FIXES: {{^}} const int kLocalConst;{{$}} +// CHECK-FIXES: const int kLocalConst; int *local_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for local pointer 'local_ptr' -// CHECK-FIXES: {{^}} int *l_LocalPtr;{{$}} +// CHECK-FIXES: int *l_LocalPtr; int *const local_const_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for local constant pointer 'local_const_ptr' -// CHECK-FIXES: {{^}} int *const lc_LocalConstPtr;{{$}} +// CHECK-FIXES: int *const lc_LocalConstPtr; }; static union { int local_static; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for static variable 'local_static' -// CHECK-FIXES: {{^}} int s_localStatic;{{$}} +// CHECK-FIXES: int s_localStatic; const int local_static_const; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for static constant 'local_static_const' -// CHECK-FIXES: {{^}} const int LOCAL_STATIC_CONST;{{$}} +// CHECK-FIXES: const int LOCAL_STATIC_CONST; int *local_static_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for static variable 'local_static_ptr' -// CHECK-FIXES: {{^}} int *s_localStaticPtr;{{$}} +// CHECK-FIXES: int *s_localStaticPtr; int *const local_static_const_ptr; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for static constant 'local_static_const_ptr' -// CHECK-FIXES: {{^}} int *const LOCAL_STATIC_CONST_PTR;{{$}} +// CHECK-FIXES: int *const LOCAL_STATIC_CONST_PTR; }; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-bugfix-name-conflicts.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-bugfix-name-conflicts.cpp index 2e79aa9..3197c5f 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-bugfix-name-conflicts.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-bugfix-name-conflicts.cpp @@ -5,9 +5,9 @@ int func(int Break) { // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for parameter 'Break'; cannot be fixed because 'break' would conflict with a keyword - // CHECK-FIXES: {{^}}int func(int Break) {{{$}} + // CHECK-FIXES: int func(int Break) { if (Break == 1) { - // CHECK-FIXES: {{^}} if (Break == 1) {{{$}} + // CHECK-FIXES: if (Break == 1) { return 2; } @@ -17,9 +17,9 @@ int func(int Break) { #define foo 3 int func2(int Foo) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for parameter 'Foo'; cannot be fixed because 'foo' would conflict with a macro definition - // CHECK-FIXES: {{^}}int func2(int Foo) {{{$}} + // CHECK-FIXES: int func2(int Foo) { if (Foo == 1) { - // CHECK-FIXES: {{^}} if (Foo == 1) {{{$}} + // CHECK-FIXES: if (Foo == 1) { return 2; } @@ -28,9 +28,9 @@ int func2(int Foo) { int func3(int _0Bad) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for parameter '_0Bad'; cannot be fixed automatically [readability-identifier-naming] - // CHECK-FIXES: {{^}}int func3(int _0Bad) {{{$}} + // CHECK-FIXES: int func3(int _0Bad) { if (_0Bad == 1) { - // CHECK-FIXES: {{^}} if (_0Bad == 1) {{{$}} + // CHECK-FIXES: if (_0Bad == 1) { return 2; } return 0; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-case-match.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-case-match.cpp index f692b01..72384e6 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-case-match.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-case-match.cpp @@ -16,27 +16,27 @@ class XML_Parser_2 {}; class XmlParser {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'XmlParser' -// CHECK-FIXES: {{^}}class Xml_Parser {};{{$}} +// CHECK-FIXES: class Xml_Parser {}; class Xml_parser {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'Xml_parser' -// CHECK-FIXES: {{^}}class Xml_Parser {};{{$}} +// CHECK-FIXES: class Xml_Parser {}; class xml_parser {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'xml_parser' -// CHECK-FIXES: {{^}}class Xml_Parser {};{{$}} +// CHECK-FIXES: class Xml_Parser {}; class xml_Parser {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'xml_Parser' -// CHECK-FIXES: {{^}}class Xml_Parser {};{{$}} +// CHECK-FIXES: class Xml_Parser {}; class xml_Parser_2 {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'xml_Parser_2' -// CHECK-FIXES: {{^}}class Xml_Parser_2 {};{{$}} +// CHECK-FIXES: class Xml_Parser_2 {}; class t {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 't' -// CHECK-FIXES: {{^}}class T {};{{$}} +// CHECK-FIXES: class T {}; //===----------------------------------------------------------------------===// // camel_Snake_Back tests @@ -48,13 +48,13 @@ struct u {}; struct JsonParser {}; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'JsonParser' -// CHECK-FIXES: {{^}}struct json_Parser {};{{$}} +// CHECK-FIXES: struct json_Parser {}; struct Json_parser {}; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'Json_parser' -// CHECK-FIXES: {{^}}struct json_Parser {};{{$}} +// CHECK-FIXES: struct json_Parser {}; struct json_parser {}; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'json_parser' -// CHECK-FIXES: {{^}}struct json_Parser {};{{$}} +// CHECK-FIXES: struct json_Parser {}; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-c-language.c b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-c-language.c index dd82c11..67f9f0d3 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-c-language.c +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-c-language.c @@ -9,95 +9,95 @@ //===----------------------------------------------------------------------===// const int GlobalConstantCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'GlobalConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int iGlobalConstantCase = 0; +// CHECK-FIXES: const int iGlobalConstantCase = 0; const int* GlobalConstantPointerCase = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global pointer 'GlobalConstantPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int* piGlobalConstantPointerCase = NULL; +// CHECK-FIXES: const int* piGlobalConstantPointerCase = NULL; int* GlobalPointerCase = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'GlobalPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int* piGlobalPointerCase = NULL; +// CHECK-FIXES: int* piGlobalPointerCase = NULL; int GlobalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iGlobalVariableCase = 0; +// CHECK-FIXES: int iGlobalVariableCase = 0; void Func1(){ int const LocalConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for local constant 'LocalConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int const iLocalConstantCase = 3; + // CHECK-FIXES: int const iLocalConstantCase = 3; unsigned const ConstantCase = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for local constant 'ConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} unsigned const uConstantCase = 1; + // CHECK-FIXES: unsigned const uConstantCase = 1; int* const LocalConstantPointerCase = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant pointer 'LocalConstantPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int* const piLocalConstantPointerCase = NULL; + // CHECK-FIXES: int* const piLocalConstantPointerCase = NULL; int *LocalPointerCase = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int *piLocalPointerCase = NULL; + // CHECK-FIXES: int *piLocalPointerCase = NULL; int LocalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int iLocalVariableCase = 0; + // CHECK-FIXES: int iLocalVariableCase = 0; } struct CMyClass2 { char MemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for public member 'MemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char cMemberCase; + // CHECK-FIXES: char cMemberCase; }; static const int StaticConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global constant 'StaticConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static const int iStaticConstantCase = 3; +// CHECK-FIXES: static const int iStaticConstantCase = 3; static int StaticVariableCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'StaticVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static int iStaticVariableCase = 3; +// CHECK-FIXES: static int iStaticVariableCase = 3; struct MyStruct { int StructCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for public member 'StructCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct MyStruct { int iStructCase; }; +// CHECK-FIXES: struct MyStruct { int iStructCase; }; struct shouldBeCamelCaseStruct { int iField; }; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'shouldBeCamelCaseStruct' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct ShouldBeCamelCaseStruct { int iField; }; +// CHECK-FIXES: struct ShouldBeCamelCaseStruct { int iField; }; union MyUnion { int UnionCase; long lUnionCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for union 'MyUnion' [readability-identifier-naming] // CHECK-MESSAGES: :[[@LINE-2]]:21: warning: invalid case style for public member 'UnionCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}union myUnion { int iUnionCase; long lUnionCase; }; +// CHECK-FIXES: union myUnion { int iUnionCase; long lUnionCase; }; //===----------------------------------------------------------------------===// // C string //===----------------------------------------------------------------------===// const char *NamePtr = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global pointer 'NamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *szNamePtr = "Name"; +// CHECK-FIXES: const char *szNamePtr = "Name"; const char NameArray[] = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global constant 'NameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char szNameArray[] = "Name"; +// CHECK-FIXES: const char szNameArray[] = "Name"; const char *NamePtrArray[] = {"AA", "BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *pszNamePtrArray[] = {"AA", "BB"}; +// CHECK-FIXES: const char *pszNamePtrArray[] = {"AA", "BB"}; const wchar_t *WideNamePtr = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'WideNamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *wszWideNamePtr = L"Name"; +// CHECK-FIXES: const wchar_t *wszWideNamePtr = L"Name"; const wchar_t WideNameArray[] = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global constant 'WideNameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t wszWideNameArray[] = L"Name"; +// CHECK-FIXES: const wchar_t wszWideNameArray[] = L"Name"; const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *pwszWideNamePtrArray[] = {L"AA", L"BB"}; +// CHECK-FIXES: const wchar_t *pwszWideNamePtrArray[] = {L"AA", L"BB"}; //===----------------------------------------------------------------------===// @@ -105,123 +105,123 @@ const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"}; //===----------------------------------------------------------------------===// DWORD MsDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD dwMsDword = 0; +// CHECK-FIXES: DWORD dwMsDword = 0; BYTE MsByte = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BYTE byMsByte = 0; +// CHECK-FIXES: BYTE byMsByte = 0; WORD MsWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD wMsWord = 0; +// CHECK-FIXES: WORD wMsWord = 0; BOOL MsBool = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOL bMsBool = 0; +// CHECK-FIXES: BOOL bMsBool = 0; BOOLEAN MsBoolean = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOLEAN bMsBoolean = 0; +// CHECK-FIXES: BOOLEAN bMsBoolean = 0; CHAR MsValueChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}CHAR cMsValueChar = 0; +// CHECK-FIXES: CHAR cMsValueChar = 0; UCHAR MsValueUchar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UCHAR ucMsValueUchar = 0; +// CHECK-FIXES: UCHAR ucMsValueUchar = 0; SHORT MsValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}SHORT sMsValueShort = 0; +// CHECK-FIXES: SHORT sMsValueShort = 0; USHORT MsValueUshort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}USHORT usMsValueUshort = 0; +// CHECK-FIXES: USHORT usMsValueUshort = 0; WORD MsValueWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD wMsValueWord = 0; +// CHECK-FIXES: WORD wMsValueWord = 0; DWORD MsValueDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD dwMsValueDword = 0; +// CHECK-FIXES: DWORD dwMsValueDword = 0; DWORD32 MsValueDword32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD32 dw32MsValueDword32 = 0; +// CHECK-FIXES: DWORD32 dw32MsValueDword32 = 0; DWORD64 MsValueDword64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD64 dw64MsValueDword64 = 0; +// CHECK-FIXES: DWORD64 dw64MsValueDword64 = 0; LONG MsValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}LONG lMsValueLong = 0; +// CHECK-FIXES: LONG lMsValueLong = 0; ULONG MsValueUlong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG ulMsValueUlong = 0; +// CHECK-FIXES: ULONG ulMsValueUlong = 0; ULONG32 MsValueUlong32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG32 ul32MsValueUlong32 = 0; +// CHECK-FIXES: ULONG32 ul32MsValueUlong32 = 0; ULONG64 MsValueUlong64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG64 ul64MsValueUlong64 = 0; +// CHECK-FIXES: ULONG64 ul64MsValueUlong64 = 0; ULONGLONG MsValueUlongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONGLONG ullMsValueUlongLong = 0; +// CHECK-FIXES: ULONGLONG ullMsValueUlongLong = 0; HANDLE MsValueHandle = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'MsValueHandle' [readability-identifier-naming] -// CHECK-FIXES: {{^}}HANDLE hMsValueHandle = 0; +// CHECK-FIXES: HANDLE hMsValueHandle = 0; INT MsValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT iMsValueInt = 0; +// CHECK-FIXES: INT iMsValueInt = 0; INT8 MsValueInt8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT8 i8MsValueInt8 = 0; +// CHECK-FIXES: INT8 i8MsValueInt8 = 0; INT16 MsValueInt16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT16 i16MsValueInt16 = 0; +// CHECK-FIXES: INT16 i16MsValueInt16 = 0; INT32 MsValueInt32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT32 i32MsValueInt32 = 0; +// CHECK-FIXES: INT32 i32MsValueInt32 = 0; INT64 MsValueINt64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT64 i64MsValueINt64 = 0; +// CHECK-FIXES: INT64 i64MsValueINt64 = 0; UINT MsValueUint = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT uiMsValueUint = 0; +// CHECK-FIXES: UINT uiMsValueUint = 0; UINT8 MsValueUint8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT8 u8MsValueUint8 = 0; +// CHECK-FIXES: UINT8 u8MsValueUint8 = 0; UINT16 MsValueUint16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT16 u16MsValueUint16 = 0; +// CHECK-FIXES: UINT16 u16MsValueUint16 = 0; UINT32 MsValueUint32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT32 u32MsValueUint32 = 0; +// CHECK-FIXES: UINT32 u32MsValueUint32 = 0; UINT64 MsValueUint64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT64 u64MsValueUint64 = 0; +// CHECK-FIXES: UINT64 u64MsValueUint64 = 0; PVOID MsValuePvoid = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'MsValuePvoid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}PVOID pMsValuePvoid = NULL; +// CHECK-FIXES: PVOID pMsValuePvoid = NULL; //===----------------------------------------------------------------------===// @@ -229,19 +229,19 @@ PVOID MsValuePvoid = NULL; //===----------------------------------------------------------------------===// unsigned GlobalUnsignedArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned aGlobalUnsignedArray[] = {1, 2, 3}; +// CHECK-FIXES: unsigned aGlobalUnsignedArray[] = {1, 2, 3}; int GlobalIntArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalIntArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int aGlobalIntArray[] = {1, 2, 3}; +// CHECK-FIXES: int aGlobalIntArray[] = {1, 2, 3}; int DataInt[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int aDataInt[1] = {0}; +// CHECK-FIXES: int aDataInt[1] = {0}; int DataArray[2] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int aDataArray[2] = {0}; +// CHECK-FIXES: int aDataArray[2] = {0}; //===----------------------------------------------------------------------===// @@ -249,56 +249,56 @@ int DataArray[2] = {0}; //===----------------------------------------------------------------------===// int *DataIntPtr[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *paDataIntPtr[1] = {0}; +// CHECK-FIXES: int *paDataIntPtr[1] = {0}; void *BufferPtr1; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'BufferPtr1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *pBufferPtr1; +// CHECK-FIXES: void *pBufferPtr1; void **BufferPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'BufferPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **ppBufferPtr2; +// CHECK-FIXES: void **ppBufferPtr2; void **pBufferPtr3; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'pBufferPtr3' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **ppBufferPtr3; +// CHECK-FIXES: void **ppBufferPtr3; int *pBufferPtr4; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'pBufferPtr4' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *piBufferPtr4; +// CHECK-FIXES: int *piBufferPtr4; typedef void (*FUNC_PTR_HELLO)(); FUNC_PTR_HELLO Hello = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'Hello' [readability-identifier-naming] -// CHECK-FIXES: {{^}}FUNC_PTR_HELLO fnHello = NULL; +// CHECK-FIXES: FUNC_PTR_HELLO fnHello = NULL; void *ValueVoidPtr = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'ValueVoidPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *pValueVoidPtr = NULL; +// CHECK-FIXES: void *pValueVoidPtr = NULL; ptrdiff_t PtrDiff = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'PtrDiff' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ptrdiff_t pPtrDiff = NULL; +// CHECK-FIXES: ptrdiff_t pPtrDiff = NULL; int8_t *ValueI8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global pointer 'ValueI8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t *pi8ValueI8Ptr; +// CHECK-FIXES: int8_t *pi8ValueI8Ptr; uint8_t *ValueU8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global pointer 'ValueU8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t *pu8ValueU8Ptr; +// CHECK-FIXES: uint8_t *pu8ValueU8Ptr; unsigned char *ValueUcPtr; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'ValueUcPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char *pucValueUcPtr; +// CHECK-FIXES: unsigned char *pucValueUcPtr; unsigned char **ValueUcPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global pointer 'ValueUcPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char **ppucValueUcPtr2; +// CHECK-FIXES: unsigned char **ppucValueUcPtr2; void MyFunc2(void* Val){} // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for pointer parameter 'Val' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void MyFunc2(void* pVal){} +// CHECK-FIXES: void MyFunc2(void* pVal){} //===----------------------------------------------------------------------===// @@ -306,151 +306,151 @@ void MyFunc2(void* Val){} //===----------------------------------------------------------------------===// int8_t ValueI8; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t i8ValueI8; +// CHECK-FIXES: int8_t i8ValueI8; int16_t ValueI16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int16_t i16ValueI16 = 0; +// CHECK-FIXES: int16_t i16ValueI16 = 0; int32_t ValueI32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int32_t i32ValueI32 = 0; +// CHECK-FIXES: int32_t i32ValueI32 = 0; int64_t ValueI64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int64_t i64ValueI64 = 0; +// CHECK-FIXES: int64_t i64ValueI64 = 0; uint8_t ValueU8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueU8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t u8ValueU8 = 0; +// CHECK-FIXES: uint8_t u8ValueU8 = 0; uint16_t ValueU16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint16_t u16ValueU16 = 0; +// CHECK-FIXES: uint16_t u16ValueU16 = 0; uint32_t ValueU32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint32_t u32ValueU32 = 0; +// CHECK-FIXES: uint32_t u32ValueU32 = 0; uint64_t ValueU64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint64_t u64ValueU64 = 0; +// CHECK-FIXES: uint64_t u64ValueU64 = 0; float ValueFloat = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming] -// CHECK-FIXES: {{^}}float fValueFloat = 0; +// CHECK-FIXES: float fValueFloat = 0; double ValueDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}double dValueDouble = 0; +// CHECK-FIXES: double dValueDouble = 0; char ValueChar = 'c'; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}char cValueChar = 'c'; +// CHECK-FIXES: char cValueChar = 'c'; bool ValueBool = true; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}bool bValueBool = true; +// CHECK-FIXES: bool bValueBool = true; int ValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iValueInt = 0; +// CHECK-FIXES: int iValueInt = 0; size_t ValueSize = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSize' [readability-identifier-naming] -// CHECK-FIXES: {{^}}size_t nValueSize = 0; +// CHECK-FIXES: size_t nValueSize = 0; wchar_t ValueWchar = 'w'; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueWchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}wchar_t wcValueWchar = 'w'; +// CHECK-FIXES: wchar_t wcValueWchar = 'w'; short ValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}short sValueShort = 0; +// CHECK-FIXES: short sValueShort = 0; unsigned ValueUnsigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned uValueUnsigned = 0; +// CHECK-FIXES: unsigned uValueUnsigned = 0; signed ValueSigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed sValueSigned = 0; +// CHECK-FIXES: signed sValueSigned = 0; long ValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long lValueLong = 0; +// CHECK-FIXES: long lValueLong = 0; long long ValueLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'ValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long llValueLongLong = 0; +// CHECK-FIXES: long long llValueLongLong = 0; long long int ValueLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long int lliValueLongLongInt = 0; +// CHECK-FIXES: long long int lliValueLongLongInt = 0; long double ValueLongDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueLongDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long double ldValueLongDouble = 0; +// CHECK-FIXES: long double ldValueLongDouble = 0; signed int ValueSignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ValueSignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed int siValueSignedInt = 0; +// CHECK-FIXES: signed int siValueSignedInt = 0; signed short ValueSignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueSignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short ssValueSignedShort = 0; +// CHECK-FIXES: signed short ssValueSignedShort = 0; signed short int ValueSignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short int ssiValueSignedShortInt = 0; +// CHECK-FIXES: signed short int ssiValueSignedShortInt = 0; signed long long ValueSignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long long sllValueSignedLongLong = 0; +// CHECK-FIXES: signed long long sllValueSignedLongLong = 0; signed long int ValueSignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global variable 'ValueSignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long int sliValueSignedLongInt = 0; +// CHECK-FIXES: signed long int sliValueSignedLongInt = 0; signed long ValueSignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueSignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long slValueSignedLong = 0; +// CHECK-FIXES: signed long slValueSignedLong = 0; unsigned long long int ValueUnsignedLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for global variable 'ValueUnsignedLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long int ulliValueUnsignedLongLongInt = 0; +// CHECK-FIXES: unsigned long long int ulliValueUnsignedLongLongInt = 0; unsigned long long ValueUnsignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long ullValueUnsignedLongLong = 0; +// CHECK-FIXES: unsigned long long ullValueUnsignedLongLong = 0; unsigned long int ValueUnsignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for global variable 'ValueUnsignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long int uliValueUnsignedLongInt = 0; +// CHECK-FIXES: unsigned long int uliValueUnsignedLongInt = 0; unsigned long ValueUnsignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long ulValueUnsignedLong = 0; +// CHECK-FIXES: unsigned long ulValueUnsignedLong = 0; unsigned short int ValueUnsignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short int usiValueUnsignedShortInt = 0; +// CHECK-FIXES: unsigned short int usiValueUnsignedShortInt = 0; unsigned short ValueUnsignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'ValueUnsignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short usValueUnsignedShort = 0; +// CHECK-FIXES: unsigned short usValueUnsignedShort = 0; unsigned int ValueUnsignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueUnsignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned int uiValueUnsignedInt = 0; +// CHECK-FIXES: unsigned int uiValueUnsignedInt = 0; unsigned char ValueUnsignedChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char ucValueUnsignedChar = 0; +// CHECK-FIXES: unsigned char ucValueUnsignedChar = 0; long int ValueLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long int liValueLongInt = 0; +// CHECK-FIXES: long int liValueLongInt = 0; //===----------------------------------------------------------------------===// @@ -458,11 +458,11 @@ long int ValueLongInt = 0; //===----------------------------------------------------------------------===// volatile int VolatileInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}volatile int iVolatileInt = 0; +// CHECK-FIXES: volatile int iVolatileInt = 0; extern int ExternValueInt; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}extern int iExternValueInt; +// CHECK-FIXES: extern int iExternValueInt; //===----------------------------------------------------------------------===// // Redefined types @@ -470,7 +470,7 @@ extern int ExternValueInt; typedef int INDEX; INDEX iIndex = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'iIndex' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INDEX Index = 0; +// CHECK-FIXES: INDEX Index = 0; //===----------------------------------------------------------------------===// @@ -478,72 +478,72 @@ INDEX iIndex = 0; //===----------------------------------------------------------------------===// int lower_case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iLowerCase = 0; +// CHECK-FIXES: int iLowerCase = 0; int lower_case1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iLowerCase1 = 0; +// CHECK-FIXES: int iLowerCase1 = 0; int lower_case_2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case_2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iLowerCase2 = 0; +// CHECK-FIXES: int iLowerCase2 = 0; int UPPER_CASE = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iUpperCase = 0; +// CHECK-FIXES: int iUpperCase = 0; int UPPER_CASE_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iUpperCase1 = 0; +// CHECK-FIXES: int iUpperCase1 = 0; int camelBack = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelBack = 0; +// CHECK-FIXES: int iCamelBack = 0; int camelBack_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelBack1 = 0; +// CHECK-FIXES: int iCamelBack1 = 0; int camelBack2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelBack2 = 0; +// CHECK-FIXES: int iCamelBack2 = 0; int CamelCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelCase = 0; +// CHECK-FIXES: int iCamelCase = 0; int CamelCase_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelCase1 = 0; +// CHECK-FIXES: int iCamelCase1 = 0; int CamelCase2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelCase2 = 0; +// CHECK-FIXES: int iCamelCase2 = 0; int camel_Snake_Back = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeBack = 0; +// CHECK-FIXES: int iCamelSnakeBack = 0; int camel_Snake_Back_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeBack1 = 0; +// CHECK-FIXES: int iCamelSnakeBack1 = 0; int Camel_Snake_Case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeCase = 0; +// CHECK-FIXES: int iCamelSnakeCase = 0; int Camel_Snake_Case_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeCase1 = 0; +// CHECK-FIXES: int iCamelSnakeCase1 = 0; //===----------------------------------------------------------------------===// // Enum //===----------------------------------------------------------------------===// enum REV_TYPE { RevValid }; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for enum constant 'RevValid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum REV_TYPE { rtRevValid }; +// CHECK-FIXES: enum REV_TYPE { rtRevValid }; enum EnumConstantCase { OneByte, TwoByte }; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for enum constant 'OneByte' [readability-identifier-naming] // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: invalid case style for enum constant 'TwoByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum EnumConstantCase { eccOneByte, eccTwoByte }; +// CHECK-FIXES: enum EnumConstantCase { eccOneByte, eccTwoByte }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp index 675f0b4..c4ac744 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp @@ -11,159 +11,159 @@ class CMyClass1 { public: static int ClassMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for class member 'ClassMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} static int myiClassMemberCase; + // CHECK-FIXES: static int myiClassMemberCase; char const ConstantMemberCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'ConstantMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char const mycConstantMemberCase = 0; + // CHECK-FIXES: char const mycConstantMemberCase = 0; void MyFunc1(const int ConstantParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for constant parameter 'ConstantParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void MyFunc1(const int myiConstantParameterCase); + // CHECK-FIXES: void MyFunc1(const int myiConstantParameterCase); void MyFunc2(const int* ConstantPointerParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: invalid case style for pointer parameter 'ConstantPointerParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void MyFunc2(const int* mypmyiConstantPointerParameterCase); + // CHECK-FIXES: void MyFunc2(const int* mypmyiConstantPointerParameterCase); static constexpr int ConstexprVariableCase = 123; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constexpr variable 'ConstexprVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} static constexpr int myiConstexprVariableCase = 123; + // CHECK-FIXES: static constexpr int myiConstexprVariableCase = 123; }; const int GlobalConstantCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'GlobalConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int myiGlobalConstantCase = 0; +// CHECK-FIXES: const int myiGlobalConstantCase = 0; const int* GlobalConstantPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global pointer 'GlobalConstantPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int* mypmyiGlobalConstantPointerCase = nullptr; +// CHECK-FIXES: const int* mypmyiGlobalConstantPointerCase = nullptr; int* GlobalPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'GlobalPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int* mypmyiGlobalPointerCase = nullptr; +// CHECK-FIXES: int* mypmyiGlobalPointerCase = nullptr; int GlobalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiGlobalVariableCase = 0; +// CHECK-FIXES: int myiGlobalVariableCase = 0; void Func1(){ int const LocalConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for local constant 'LocalConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int const myiLocalConstantCase = 3; + // CHECK-FIXES: int const myiLocalConstantCase = 3; unsigned const ConstantCase = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for local constant 'ConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} unsigned const myuConstantCase = 1; + // CHECK-FIXES: unsigned const myuConstantCase = 1; int* const LocalConstantPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant pointer 'LocalConstantPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int* const mypmyiLocalConstantPointerCase = nullptr; + // CHECK-FIXES: int* const mypmyiLocalConstantPointerCase = nullptr; int *LocalPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int *mypmyiLocalPointerCase = nullptr; + // CHECK-FIXES: int *mypmyiLocalPointerCase = nullptr; int LocalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int myiLocalVariableCase = 0; + // CHECK-FIXES: int myiLocalVariableCase = 0; } class CMyClass2 { char MemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'MemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char mycMemberCase; + // CHECK-FIXES: char mycMemberCase; void Func1(int ParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'ParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func1(int myiParameterCase); + // CHECK-FIXES: void Func1(int myiParameterCase); void Func2(const int ParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constant parameter 'ParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func2(const int myiParameterCase); + // CHECK-FIXES: void Func2(const int myiParameterCase); void Func3(const int *PointerParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for pointer parameter 'PointerParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func3(const int *mypmyiPointerParameterCase); + // CHECK-FIXES: void Func3(const int *mypmyiPointerParameterCase); }; class CMyClass3 { private: char PrivateMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'PrivateMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char mycPrivateMemberCase; + // CHECK-FIXES: char mycPrivateMemberCase; protected: char ProtectedMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for protected member 'ProtectedMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char mycProtectedMemberCase; + // CHECK-FIXES: char mycProtectedMemberCase; public: char PublicMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for public member 'PublicMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char mycPublicMemberCase; + // CHECK-FIXES: char mycPublicMemberCase; }; static const int StaticConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global constant 'StaticConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static const int myiStaticConstantCase = 3; +// CHECK-FIXES: static const int myiStaticConstantCase = 3; static int StaticVariableCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'StaticVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static int myiStaticVariableCase = 3; +// CHECK-FIXES: static int myiStaticVariableCase = 3; struct CMyStruct { int StructCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for public member 'StructCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct CMyStruct { int myiStructCase; }; +// CHECK-FIXES: struct CMyStruct { int myiStructCase; }; union MyUnion { int UnionCase; long mylUnionCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for public member 'UnionCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}union MyUnion { int myiUnionCase; long mylUnionCase; }; +// CHECK-FIXES: union MyUnion { int myiUnionCase; long mylUnionCase; }; //===----------------------------------------------------------------------===// // C string //===----------------------------------------------------------------------===// const char *NamePtr = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global pointer 'NamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *myszNamePtr = "Name"; +// CHECK-FIXES: const char *myszNamePtr = "Name"; const char NameArray[] = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global constant 'NameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char myszNameArray[] = "Name"; +// CHECK-FIXES: const char myszNameArray[] = "Name"; const char *NamePtrArray[] = {"AA", "BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *mypmyszNamePtrArray[] = {"AA", "BB"}; +// CHECK-FIXES: const char *mypmyszNamePtrArray[] = {"AA", "BB"}; const wchar_t *WideNamePtr = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'WideNamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *mywszWideNamePtr = L"Name"; +// CHECK-FIXES: const wchar_t *mywszWideNamePtr = L"Name"; const wchar_t WideNameArray[] = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global constant 'WideNameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t mywszWideNameArray[] = L"Name"; +// CHECK-FIXES: const wchar_t mywszWideNameArray[] = L"Name"; const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *mypmywszWideNamePtrArray[] = {L"AA", L"BB"}; +// CHECK-FIXES: const wchar_t *mypmywszWideNamePtrArray[] = {L"AA", L"BB"}; class CMyClass4 { private: char *Name = "Text"; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'Name' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char *myszName = "Text"; + // CHECK-FIXES: char *myszName = "Text"; const char *ConstName = "Text"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for private member 'ConstName' [readability-identifier-naming] - // CHECK-FIXES: {{^}} const char *myszConstName = "Text"; + // CHECK-FIXES: const char *myszConstName = "Text"; public: const char* DuplicateString(const char* Input, size_t mynRequiredSize); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: invalid case style for pointer parameter 'Input' [readability-identifier-naming] - // CHECK-FIXES: {{^}} const char* DuplicateString(const char* myszInput, size_t mynRequiredSize); + // CHECK-FIXES: const char* DuplicateString(const char* myszInput, size_t mynRequiredSize); size_t UpdateText(const char* Buffer, size_t mynBufferSize); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: invalid case style for pointer parameter 'Buffer' [readability-identifier-naming] - // CHECK-FIXES: {{^}} size_t UpdateText(const char* myszBuffer, size_t mynBufferSize); + // CHECK-FIXES: size_t UpdateText(const char* myszBuffer, size_t mynBufferSize); }; @@ -172,123 +172,123 @@ public: //===----------------------------------------------------------------------===// DWORD MsDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD mydwMsDword = 0; +// CHECK-FIXES: DWORD mydwMsDword = 0; BYTE MsByte = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BYTE mybyMsByte = 0; +// CHECK-FIXES: BYTE mybyMsByte = 0; WORD MsWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD mywMsWord = 0; +// CHECK-FIXES: WORD mywMsWord = 0; BOOL MsBool = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOL mybMsBool = 0; +// CHECK-FIXES: BOOL mybMsBool = 0; BOOLEAN MsBoolean = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOLEAN mybMsBoolean = 0; +// CHECK-FIXES: BOOLEAN mybMsBoolean = 0; CHAR MsValueChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}CHAR mycMsValueChar = 0; +// CHECK-FIXES: CHAR mycMsValueChar = 0; UCHAR MsValueUchar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UCHAR myucMsValueUchar = 0; +// CHECK-FIXES: UCHAR myucMsValueUchar = 0; SHORT MsValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}SHORT mysMsValueShort = 0; +// CHECK-FIXES: SHORT mysMsValueShort = 0; USHORT MsValueUshort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}USHORT myusMsValueUshort = 0; +// CHECK-FIXES: USHORT myusMsValueUshort = 0; WORD MsValueWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD mywMsValueWord = 0; +// CHECK-FIXES: WORD mywMsValueWord = 0; DWORD MsValueDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD mydwMsValueDword = 0; +// CHECK-FIXES: DWORD mydwMsValueDword = 0; DWORD32 MsValueDword32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD32 mydw32MsValueDword32 = 0; +// CHECK-FIXES: DWORD32 mydw32MsValueDword32 = 0; DWORD64 MsValueDword64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD64 mydw64MsValueDword64 = 0; +// CHECK-FIXES: DWORD64 mydw64MsValueDword64 = 0; LONG MsValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}LONG mylMsValueLong = 0; +// CHECK-FIXES: LONG mylMsValueLong = 0; ULONG MsValueUlong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG myulMsValueUlong = 0; +// CHECK-FIXES: ULONG myulMsValueUlong = 0; ULONG32 MsValueUlong32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG32 myul32MsValueUlong32 = 0; +// CHECK-FIXES: ULONG32 myul32MsValueUlong32 = 0; ULONG64 MsValueUlong64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG64 myul64MsValueUlong64 = 0; +// CHECK-FIXES: ULONG64 myul64MsValueUlong64 = 0; ULONGLONG MsValueUlongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONGLONG myullMsValueUlongLong = 0; +// CHECK-FIXES: ULONGLONG myullMsValueUlongLong = 0; HANDLE MsValueHandle = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'MsValueHandle' [readability-identifier-naming] -// CHECK-FIXES: {{^}}HANDLE myhMsValueHandle = 0; +// CHECK-FIXES: HANDLE myhMsValueHandle = 0; INT MsValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT myiMsValueInt = 0; +// CHECK-FIXES: INT myiMsValueInt = 0; INT8 MsValueInt8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT8 myi8MsValueInt8 = 0; +// CHECK-FIXES: INT8 myi8MsValueInt8 = 0; INT16 MsValueInt16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT16 myi16MsValueInt16 = 0; +// CHECK-FIXES: INT16 myi16MsValueInt16 = 0; INT32 MsValueInt32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT32 myi32MsValueInt32 = 0; +// CHECK-FIXES: INT32 myi32MsValueInt32 = 0; INT64 MsValueINt64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT64 myi64MsValueINt64 = 0; +// CHECK-FIXES: INT64 myi64MsValueINt64 = 0; UINT MsValueUint = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT myuiMsValueUint = 0; +// CHECK-FIXES: UINT myuiMsValueUint = 0; UINT8 MsValueUint8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT8 myu8MsValueUint8 = 0; +// CHECK-FIXES: UINT8 myu8MsValueUint8 = 0; UINT16 MsValueUint16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT16 myu16MsValueUint16 = 0; +// CHECK-FIXES: UINT16 myu16MsValueUint16 = 0; UINT32 MsValueUint32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT32 myu32MsValueUint32 = 0; +// CHECK-FIXES: UINT32 myu32MsValueUint32 = 0; UINT64 MsValueUint64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT64 myu64MsValueUint64 = 0; +// CHECK-FIXES: UINT64 myu64MsValueUint64 = 0; PVOID MsValuePvoid = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'MsValuePvoid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}PVOID mypMsValuePvoid = NULL; +// CHECK-FIXES: PVOID mypMsValuePvoid = NULL; //===----------------------------------------------------------------------===// @@ -296,19 +296,19 @@ PVOID MsValuePvoid = NULL; //===----------------------------------------------------------------------===// unsigned GlobalUnsignedArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned myaGlobalUnsignedArray[] = {1, 2, 3}; +// CHECK-FIXES: unsigned myaGlobalUnsignedArray[] = {1, 2, 3}; int GlobalIntArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalIntArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myaGlobalIntArray[] = {1, 2, 3}; +// CHECK-FIXES: int myaGlobalIntArray[] = {1, 2, 3}; int DataInt[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myaDataInt[1] = {0}; +// CHECK-FIXES: int myaDataInt[1] = {0}; int DataArray[2] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myaDataArray[2] = {0}; +// CHECK-FIXES: int myaDataArray[2] = {0}; //===----------------------------------------------------------------------===// @@ -316,56 +316,56 @@ int DataArray[2] = {0}; //===----------------------------------------------------------------------===// int *DataIntPtr[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *mypmyaDataIntPtr[1] = {0}; +// CHECK-FIXES: int *mypmyaDataIntPtr[1] = {0}; void *BufferPtr1; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'BufferPtr1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *mypmyvBufferPtr1; +// CHECK-FIXES: void *mypmyvBufferPtr1; void **BufferPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'BufferPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **mypmypmyvBufferPtr2; +// CHECK-FIXES: void **mypmypmyvBufferPtr2; void **mypBufferPtr3; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'mypBufferPtr3' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **mypmypmyvBufferPtr3; +// CHECK-FIXES: void **mypmypmyvBufferPtr3; int *mypBufferPtr4; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'mypBufferPtr4' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *mypmyiBufferPtr4; +// CHECK-FIXES: int *mypmyiBufferPtr4; typedef void (*FUNC_PTR_HELLO)(); FUNC_PTR_HELLO Hello = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'Hello' [readability-identifier-naming] -// CHECK-FIXES: {{^}}FUNC_PTR_HELLO myfnHello = NULL; +// CHECK-FIXES: FUNC_PTR_HELLO myfnHello = NULL; void *ValueVoidPtr = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'ValueVoidPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *mypmyvValueVoidPtr = NULL; +// CHECK-FIXES: void *mypmyvValueVoidPtr = NULL; ptrdiff_t PtrDiff = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'PtrDiff' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ptrdiff_t mypPtrDiff = NULL; +// CHECK-FIXES: ptrdiff_t mypPtrDiff = NULL; int8_t *ValueI8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global pointer 'ValueI8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t *mypmyi8ValueI8Ptr; +// CHECK-FIXES: int8_t *mypmyi8ValueI8Ptr; uint8_t *ValueU8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global pointer 'ValueU8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t *mypmyu8ValueU8Ptr; +// CHECK-FIXES: uint8_t *mypmyu8ValueU8Ptr; unsigned char *ValueUcPtr; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'ValueUcPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char *mypmyucValueUcPtr; +// CHECK-FIXES: unsigned char *mypmyucValueUcPtr; unsigned char **ValueUcPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global pointer 'ValueUcPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char **mypmypmyucValueUcPtr2; +// CHECK-FIXES: unsigned char **mypmypmyucValueUcPtr2; void MyFunc2(void* Val){} // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for pointer parameter 'Val' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void MyFunc2(void* mypmyvVal){} +// CHECK-FIXES: void MyFunc2(void* mypmyvVal){} //===----------------------------------------------------------------------===// @@ -374,16 +374,16 @@ void MyFunc2(void* Val){} int myiValueIndex = 1; int &RefValueIndex = myiValueIndex; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'RefValueIndex' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int &myiRefValueIndex = myiValueIndex; +// CHECK-FIXES: int &myiRefValueIndex = myiValueIndex; const int &ConstRefValue = myiValueIndex; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ConstRefValue' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int &myiConstRefValue = myiValueIndex; +// CHECK-FIXES: const int &myiConstRefValue = myiValueIndex; long long myllValueLongLong = 2; long long &RefValueLongLong = myllValueLongLong; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'RefValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long &myllRefValueLongLong = myllValueLongLong; +// CHECK-FIXES: long long &myllRefValueLongLong = myllValueLongLong; //===----------------------------------------------------------------------===// @@ -391,151 +391,151 @@ long long &RefValueLongLong = myllValueLongLong; //===----------------------------------------------------------------------===// int8_t ValueI8; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t myi8ValueI8; +// CHECK-FIXES: int8_t myi8ValueI8; int16_t ValueI16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int16_t myi16ValueI16 = 0; +// CHECK-FIXES: int16_t myi16ValueI16 = 0; int32_t ValueI32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int32_t myi32ValueI32 = 0; +// CHECK-FIXES: int32_t myi32ValueI32 = 0; int64_t ValueI64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int64_t myi64ValueI64 = 0; +// CHECK-FIXES: int64_t myi64ValueI64 = 0; uint8_t ValueU8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueU8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t myu8ValueU8 = 0; +// CHECK-FIXES: uint8_t myu8ValueU8 = 0; uint16_t ValueU16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint16_t myu16ValueU16 = 0; +// CHECK-FIXES: uint16_t myu16ValueU16 = 0; uint32_t ValueU32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint32_t myu32ValueU32 = 0; +// CHECK-FIXES: uint32_t myu32ValueU32 = 0; uint64_t ValueU64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint64_t myu64ValueU64 = 0; +// CHECK-FIXES: uint64_t myu64ValueU64 = 0; float ValueFloat = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming] -// CHECK-FIXES: {{^}}float myfValueFloat = 0; +// CHECK-FIXES: float myfValueFloat = 0; double ValueDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}double mydValueDouble = 0; +// CHECK-FIXES: double mydValueDouble = 0; char ValueChar = 'c'; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}char mycValueChar = 'c'; +// CHECK-FIXES: char mycValueChar = 'c'; bool ValueBool = true; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}bool mybValueBool = true; +// CHECK-FIXES: bool mybValueBool = true; int ValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiValueInt = 0; +// CHECK-FIXES: int myiValueInt = 0; size_t ValueSize = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSize' [readability-identifier-naming] -// CHECK-FIXES: {{^}}size_t mynValueSize = 0; +// CHECK-FIXES: size_t mynValueSize = 0; wchar_t ValueWchar = 'w'; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueWchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}wchar_t mywcValueWchar = 'w'; +// CHECK-FIXES: wchar_t mywcValueWchar = 'w'; short ValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}short mysValueShort = 0; +// CHECK-FIXES: short mysValueShort = 0; unsigned ValueUnsigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned myuValueUnsigned = 0; +// CHECK-FIXES: unsigned myuValueUnsigned = 0; signed ValueSigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed mysValueSigned = 0; +// CHECK-FIXES: signed mysValueSigned = 0; long ValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long mylValueLong = 0; +// CHECK-FIXES: long mylValueLong = 0; long long ValueLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'ValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long myllValueLongLong = 0; +// CHECK-FIXES: long long myllValueLongLong = 0; long long int ValueLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long int mylliValueLongLongInt = 0; +// CHECK-FIXES: long long int mylliValueLongLongInt = 0; long double ValueLongDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueLongDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long double myldValueLongDouble = 0; +// CHECK-FIXES: long double myldValueLongDouble = 0; signed int ValueSignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ValueSignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed int mysiValueSignedInt = 0; +// CHECK-FIXES: signed int mysiValueSignedInt = 0; signed short ValueSignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueSignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short myssValueSignedShort = 0; +// CHECK-FIXES: signed short myssValueSignedShort = 0; signed short int ValueSignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short int myssiValueSignedShortInt = 0; +// CHECK-FIXES: signed short int myssiValueSignedShortInt = 0; signed long long ValueSignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long long mysllValueSignedLongLong = 0; +// CHECK-FIXES: signed long long mysllValueSignedLongLong = 0; signed long int ValueSignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global variable 'ValueSignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long int mysliValueSignedLongInt = 0; +// CHECK-FIXES: signed long int mysliValueSignedLongInt = 0; signed long ValueSignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueSignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long myslValueSignedLong = 0; +// CHECK-FIXES: signed long myslValueSignedLong = 0; unsigned long long int ValueUnsignedLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for global variable 'ValueUnsignedLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long int myulliValueUnsignedLongLongInt = 0; +// CHECK-FIXES: unsigned long long int myulliValueUnsignedLongLongInt = 0; unsigned long long ValueUnsignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long myullValueUnsignedLongLong = 0; +// CHECK-FIXES: unsigned long long myullValueUnsignedLongLong = 0; unsigned long int ValueUnsignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for global variable 'ValueUnsignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long int myuliValueUnsignedLongInt = 0; +// CHECK-FIXES: unsigned long int myuliValueUnsignedLongInt = 0; unsigned long ValueUnsignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long myulValueUnsignedLong = 0; +// CHECK-FIXES: unsigned long myulValueUnsignedLong = 0; unsigned short int ValueUnsignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short int myusiValueUnsignedShortInt = 0; +// CHECK-FIXES: unsigned short int myusiValueUnsignedShortInt = 0; unsigned short ValueUnsignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'ValueUnsignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short myusValueUnsignedShort = 0; +// CHECK-FIXES: unsigned short myusValueUnsignedShort = 0; unsigned int ValueUnsignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueUnsignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned int myuiValueUnsignedInt = 0; +// CHECK-FIXES: unsigned int myuiValueUnsignedInt = 0; unsigned char ValueUnsignedChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char myucValueUnsignedChar = 0; +// CHECK-FIXES: unsigned char myucValueUnsignedChar = 0; long int ValueLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long int myliValueLongInt = 0; +// CHECK-FIXES: long int myliValueLongInt = 0; //===----------------------------------------------------------------------===// @@ -543,25 +543,25 @@ long int ValueLongInt = 0; //===----------------------------------------------------------------------===// volatile int VolatileInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}volatile int myiVolatileInt = 0; +// CHECK-FIXES: volatile int myiVolatileInt = 0; thread_local int ThreadLocalValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ThreadLocalValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}thread_local int myiThreadLocalValueInt = 0; +// CHECK-FIXES: thread_local int myiThreadLocalValueInt = 0; extern int ExternValueInt; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}extern int myiExternValueInt; +// CHECK-FIXES: extern int myiExternValueInt; struct CDataBuffer { mutable size_t Size; }; // CHECK-MESSAGES: :[[@LINE-2]]:20: warning: invalid case style for public member 'Size' [readability-identifier-naming] -// CHECK-FIXES: {{^}} mutable size_t mynSize; +// CHECK-FIXES: mutable size_t mynSize; static constexpr int const &ConstExprInt = 42; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: invalid case style for constexpr variable 'ConstExprInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static constexpr int const &myiConstExprInt = 42; +// CHECK-FIXES: static constexpr int const &myiConstExprInt = 42; //===----------------------------------------------------------------------===// @@ -570,7 +570,7 @@ static constexpr int const &ConstExprInt = 42; typedef int INDEX; INDEX myiIndex = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'myiIndex' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INDEX Index = 0; +// CHECK-FIXES: INDEX Index = 0; //===----------------------------------------------------------------------===// @@ -578,100 +578,100 @@ INDEX myiIndex = 0; //===----------------------------------------------------------------------===// class ClassCase { int Func(); }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class CClassCase { int Func(); }; +// CHECK-FIXES: class CClassCase { int Func(); }; class AbstractClassCase { virtual int Func() = 0; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClassCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class IAbstractClassCase { virtual int Func() = 0; }; +// CHECK-FIXES: class IAbstractClassCase { virtual int Func() = 0; }; class AbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClassCase1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class IAbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; +// CHECK-FIXES: class IAbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; class ClassConstantCase { public: static const int myiConstantCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class CClassConstantCase { public: static const int myiConstantCase; }; +// CHECK-FIXES: class CClassConstantCase { public: static const int myiConstantCase; }; struct StructCase { int Func(); }; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for class 'StructCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct CStructCase { int Func(); }; +// CHECK-FIXES: struct CStructCase { int Func(); }; //===----------------------------------------------------------------------===// // Other Cases //===----------------------------------------------------------------------===// int lower_case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiLowerCase = 0; +// CHECK-FIXES: int myiLowerCase = 0; int lower_case1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiLowerCase1 = 0; +// CHECK-FIXES: int myiLowerCase1 = 0; int lower_case_2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case_2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiLowerCase2 = 0; +// CHECK-FIXES: int myiLowerCase2 = 0; int UPPER_CASE = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiUpperCase = 0; +// CHECK-FIXES: int myiUpperCase = 0; int UPPER_CASE_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiUpperCase1 = 0; +// CHECK-FIXES: int myiUpperCase1 = 0; int camelBack = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelBack = 0; +// CHECK-FIXES: int myiCamelBack = 0; int camelBack_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelBack1 = 0; +// CHECK-FIXES: int myiCamelBack1 = 0; int camelBack2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelBack2 = 0; +// CHECK-FIXES: int myiCamelBack2 = 0; int CamelCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelCase = 0; +// CHECK-FIXES: int myiCamelCase = 0; int CamelCase_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelCase1 = 0; +// CHECK-FIXES: int myiCamelCase1 = 0; int CamelCase2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelCase2 = 0; +// CHECK-FIXES: int myiCamelCase2 = 0; int camel_Snake_Back = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelSnakeBack = 0; +// CHECK-FIXES: int myiCamelSnakeBack = 0; int camel_Snake_Back_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelSnakeBack1 = 0; +// CHECK-FIXES: int myiCamelSnakeBack1 = 0; int Camel_Snake_Case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelSnakeCase = 0; +// CHECK-FIXES: int myiCamelSnakeCase = 0; int Camel_Snake_Case_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int myiCamelSnakeCase1 = 0; +// CHECK-FIXES: int myiCamelSnakeCase1 = 0; //===----------------------------------------------------------------------===// // Enum //===----------------------------------------------------------------------===// enum REV_TYPE { RevValid }; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for enum constant 'RevValid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum REV_TYPE { rtRevValid }; +// CHECK-FIXES: enum REV_TYPE { rtRevValid }; enum EnumConstantCase { OneByte, TwoByte }; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for enum constant 'OneByte' [readability-identifier-naming] // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: invalid case style for enum constant 'TwoByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum EnumConstantCase { eccOneByte, eccTwoByte }; +// CHECK-FIXES: enum EnumConstantCase { eccOneByte, eccTwoByte }; enum class ScopedEnumConstantCase { Case1 }; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: invalid case style for scoped enum constant 'Case1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum class ScopedEnumConstantCase { seccCase1 }; +// CHECK-FIXES: enum class ScopedEnumConstantCase { seccCase1 }; // clang-format on diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation.cpp index b974fae..083a7f2 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation.cpp @@ -11,164 +11,164 @@ class CMyClass1 { public: static int ClassMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for class member 'ClassMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} static int iClassMemberCase; + // CHECK-FIXES: static int iClassMemberCase; char const ConstantMemberCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'ConstantMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char const cConstantMemberCase = 0; + // CHECK-FIXES: char const cConstantMemberCase = 0; void MyFunc1(const int ConstantParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for constant parameter 'ConstantParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void MyFunc1(const int iConstantParameterCase); + // CHECK-FIXES: void MyFunc1(const int iConstantParameterCase); void MyFunc2(const int* ConstantPointerParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: invalid case style for pointer parameter 'ConstantPointerParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void MyFunc2(const int* piConstantPointerParameterCase); + // CHECK-FIXES: void MyFunc2(const int* piConstantPointerParameterCase); static constexpr int ConstexprVariableCase = 123; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constexpr variable 'ConstexprVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} static constexpr int iConstexprVariableCase = 123; + // CHECK-FIXES: static constexpr int iConstexprVariableCase = 123; }; const int GlobalConstantCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'GlobalConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int iGlobalConstantCase = 0; +// CHECK-FIXES: const int iGlobalConstantCase = 0; const int* GlobalConstantPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global pointer 'GlobalConstantPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int* piGlobalConstantPointerCase = nullptr; +// CHECK-FIXES: const int* piGlobalConstantPointerCase = nullptr; int* GlobalPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'GlobalPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int* piGlobalPointerCase = nullptr; +// CHECK-FIXES: int* piGlobalPointerCase = nullptr; int GlobalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iGlobalVariableCase = 0; +// CHECK-FIXES: int iGlobalVariableCase = 0; void Func1(){ int const LocalConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for local constant 'LocalConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int const iLocalConstantCase = 3; + // CHECK-FIXES: int const iLocalConstantCase = 3; unsigned const ConstantCase = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for local constant 'ConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} unsigned const uConstantCase = 1; + // CHECK-FIXES: unsigned const uConstantCase = 1; int* const LocalConstantPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant pointer 'LocalConstantPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int* const piLocalConstantPointerCase = nullptr; + // CHECK-FIXES: int* const piLocalConstantPointerCase = nullptr; int *LocalPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int *piLocalPointerCase = nullptr; + // CHECK-FIXES: int *piLocalPointerCase = nullptr; int LocalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int iLocalVariableCase = 0; + // CHECK-FIXES: int iLocalVariableCase = 0; } class CMyClass2 { char MemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'MemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char cMemberCase; + // CHECK-FIXES: char cMemberCase; void Func1(int ParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'ParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func1(int iParameterCase); + // CHECK-FIXES: void Func1(int iParameterCase); void Func2(const int ParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constant parameter 'ParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func2(const int iParameterCase); + // CHECK-FIXES: void Func2(const int iParameterCase); void Func3(const int *PointerParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for pointer parameter 'PointerParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func3(const int *piPointerParameterCase); + // CHECK-FIXES: void Func3(const int *piPointerParameterCase); }; class CMyClass3 { private: char PrivateMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'PrivateMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char cPrivateMemberCase; + // CHECK-FIXES: char cPrivateMemberCase; protected: char ProtectedMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for protected member 'ProtectedMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char cProtectedMemberCase; + // CHECK-FIXES: char cProtectedMemberCase; public: char PublicMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for public member 'PublicMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char cPublicMemberCase; + // CHECK-FIXES: char cPublicMemberCase; }; static const int StaticConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global constant 'StaticConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static const int iStaticConstantCase = 3; +// CHECK-FIXES: static const int iStaticConstantCase = 3; static int StaticVariableCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'StaticVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static int iStaticVariableCase = 3; +// CHECK-FIXES: static int iStaticVariableCase = 3; struct MyStruct { int StructCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for public member 'StructCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct MyStruct { int iStructCase; }; +// CHECK-FIXES: struct MyStruct { int iStructCase; }; struct shouldBeCamelCaseStruct { int iField; }; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'shouldBeCamelCaseStruct' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct ShouldBeCamelCaseStruct { int iField; }; +// CHECK-FIXES: struct ShouldBeCamelCaseStruct { int iField; }; union MyUnion { int UnionCase; long lUnionCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for union 'MyUnion' [readability-identifier-naming] // CHECK-MESSAGES: :[[@LINE-2]]:21: warning: invalid case style for public member 'UnionCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}union myUnion { int iUnionCase; long lUnionCase; }; +// CHECK-FIXES: union myUnion { int iUnionCase; long lUnionCase; }; //===----------------------------------------------------------------------===// // C string //===----------------------------------------------------------------------===// const char *NamePtr = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global pointer 'NamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *szNamePtr = "Name"; +// CHECK-FIXES: const char *szNamePtr = "Name"; const char NameArray[] = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global constant 'NameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char szNameArray[] = "Name"; +// CHECK-FIXES: const char szNameArray[] = "Name"; const char *NamePtrArray[] = {"AA", "BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *pszNamePtrArray[] = {"AA", "BB"}; +// CHECK-FIXES: const char *pszNamePtrArray[] = {"AA", "BB"}; const wchar_t *WideNamePtr = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'WideNamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *wszWideNamePtr = L"Name"; +// CHECK-FIXES: const wchar_t *wszWideNamePtr = L"Name"; const wchar_t WideNameArray[] = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global constant 'WideNameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t wszWideNameArray[] = L"Name"; +// CHECK-FIXES: const wchar_t wszWideNameArray[] = L"Name"; const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *pwszWideNamePtrArray[] = {L"AA", L"BB"}; +// CHECK-FIXES: const wchar_t *pwszWideNamePtrArray[] = {L"AA", L"BB"}; class CMyClass4 { private: char *Name = "Text"; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'Name' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char *szName = "Text"; + // CHECK-FIXES: char *szName = "Text"; const char *ConstName = "Text"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for private member 'ConstName' [readability-identifier-naming] - // CHECK-FIXES: {{^}} const char *szConstName = "Text"; + // CHECK-FIXES: const char *szConstName = "Text"; public: const char* DuplicateString(const char* Input, size_t nRequiredSize); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: invalid case style for pointer parameter 'Input' [readability-identifier-naming] - // CHECK-FIXES: {{^}} const char* DuplicateString(const char* szInput, size_t nRequiredSize); + // CHECK-FIXES: const char* DuplicateString(const char* szInput, size_t nRequiredSize); size_t UpdateText(const char* Buffer, size_t nBufferSize); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: invalid case style for pointer parameter 'Buffer' [readability-identifier-naming] - // CHECK-FIXES: {{^}} size_t UpdateText(const char* szBuffer, size_t nBufferSize); + // CHECK-FIXES: size_t UpdateText(const char* szBuffer, size_t nBufferSize); }; @@ -177,123 +177,123 @@ public: //===----------------------------------------------------------------------===// DWORD MsDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD dwMsDword = 0; +// CHECK-FIXES: DWORD dwMsDword = 0; BYTE MsByte = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BYTE byMsByte = 0; +// CHECK-FIXES: BYTE byMsByte = 0; WORD MsWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD wMsWord = 0; +// CHECK-FIXES: WORD wMsWord = 0; BOOL MsBool = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOL bMsBool = 0; +// CHECK-FIXES: BOOL bMsBool = 0; BOOLEAN MsBoolean = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOLEAN bMsBoolean = 0; +// CHECK-FIXES: BOOLEAN bMsBoolean = 0; CHAR MsValueChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}CHAR cMsValueChar = 0; +// CHECK-FIXES: CHAR cMsValueChar = 0; UCHAR MsValueUchar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UCHAR ucMsValueUchar = 0; +// CHECK-FIXES: UCHAR ucMsValueUchar = 0; SHORT MsValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}SHORT sMsValueShort = 0; +// CHECK-FIXES: SHORT sMsValueShort = 0; USHORT MsValueUshort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}USHORT usMsValueUshort = 0; +// CHECK-FIXES: USHORT usMsValueUshort = 0; WORD MsValueWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD wMsValueWord = 0; +// CHECK-FIXES: WORD wMsValueWord = 0; DWORD MsValueDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD dwMsValueDword = 0; +// CHECK-FIXES: DWORD dwMsValueDword = 0; DWORD32 MsValueDword32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD32 dw32MsValueDword32 = 0; +// CHECK-FIXES: DWORD32 dw32MsValueDword32 = 0; DWORD64 MsValueDword64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD64 dw64MsValueDword64 = 0; +// CHECK-FIXES: DWORD64 dw64MsValueDword64 = 0; LONG MsValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}LONG lMsValueLong = 0; +// CHECK-FIXES: LONG lMsValueLong = 0; ULONG MsValueUlong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG ulMsValueUlong = 0; +// CHECK-FIXES: ULONG ulMsValueUlong = 0; ULONG32 MsValueUlong32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG32 ul32MsValueUlong32 = 0; +// CHECK-FIXES: ULONG32 ul32MsValueUlong32 = 0; ULONG64 MsValueUlong64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG64 ul64MsValueUlong64 = 0; +// CHECK-FIXES: ULONG64 ul64MsValueUlong64 = 0; ULONGLONG MsValueUlongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONGLONG ullMsValueUlongLong = 0; +// CHECK-FIXES: ULONGLONG ullMsValueUlongLong = 0; HANDLE MsValueHandle = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'MsValueHandle' [readability-identifier-naming] -// CHECK-FIXES: {{^}}HANDLE hMsValueHandle = 0; +// CHECK-FIXES: HANDLE hMsValueHandle = 0; INT MsValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT iMsValueInt = 0; +// CHECK-FIXES: INT iMsValueInt = 0; INT8 MsValueInt8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT8 i8MsValueInt8 = 0; +// CHECK-FIXES: INT8 i8MsValueInt8 = 0; INT16 MsValueInt16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT16 i16MsValueInt16 = 0; +// CHECK-FIXES: INT16 i16MsValueInt16 = 0; INT32 MsValueInt32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT32 i32MsValueInt32 = 0; +// CHECK-FIXES: INT32 i32MsValueInt32 = 0; INT64 MsValueINt64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT64 i64MsValueINt64 = 0; +// CHECK-FIXES: INT64 i64MsValueINt64 = 0; UINT MsValueUint = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT uiMsValueUint = 0; +// CHECK-FIXES: UINT uiMsValueUint = 0; UINT8 MsValueUint8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT8 u8MsValueUint8 = 0; +// CHECK-FIXES: UINT8 u8MsValueUint8 = 0; UINT16 MsValueUint16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT16 u16MsValueUint16 = 0; +// CHECK-FIXES: UINT16 u16MsValueUint16 = 0; UINT32 MsValueUint32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT32 u32MsValueUint32 = 0; +// CHECK-FIXES: UINT32 u32MsValueUint32 = 0; UINT64 MsValueUint64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT64 u64MsValueUint64 = 0; +// CHECK-FIXES: UINT64 u64MsValueUint64 = 0; PVOID MsValuePvoid = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'MsValuePvoid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}PVOID pMsValuePvoid = NULL; +// CHECK-FIXES: PVOID pMsValuePvoid = NULL; //===----------------------------------------------------------------------===// @@ -301,19 +301,19 @@ PVOID MsValuePvoid = NULL; //===----------------------------------------------------------------------===// unsigned GlobalUnsignedArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned aGlobalUnsignedArray[] = {1, 2, 3}; +// CHECK-FIXES: unsigned aGlobalUnsignedArray[] = {1, 2, 3}; int GlobalIntArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalIntArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int aGlobalIntArray[] = {1, 2, 3}; +// CHECK-FIXES: int aGlobalIntArray[] = {1, 2, 3}; int DataInt[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int aDataInt[1] = {0}; +// CHECK-FIXES: int aDataInt[1] = {0}; int DataArray[2] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int aDataArray[2] = {0}; +// CHECK-FIXES: int aDataArray[2] = {0}; //===----------------------------------------------------------------------===// @@ -321,56 +321,56 @@ int DataArray[2] = {0}; //===----------------------------------------------------------------------===// int *DataIntPtr[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *paDataIntPtr[1] = {0}; +// CHECK-FIXES: int *paDataIntPtr[1] = {0}; void *BufferPtr1; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'BufferPtr1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *pBufferPtr1; +// CHECK-FIXES: void *pBufferPtr1; void **BufferPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'BufferPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **ppBufferPtr2; +// CHECK-FIXES: void **ppBufferPtr2; void **pBufferPtr3; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'pBufferPtr3' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **ppBufferPtr3; +// CHECK-FIXES: void **ppBufferPtr3; int *pBufferPtr4; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'pBufferPtr4' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *piBufferPtr4; +// CHECK-FIXES: int *piBufferPtr4; typedef void (*FUNC_PTR_HELLO)(); FUNC_PTR_HELLO Hello = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'Hello' [readability-identifier-naming] -// CHECK-FIXES: {{^}}FUNC_PTR_HELLO fnHello = NULL; +// CHECK-FIXES: FUNC_PTR_HELLO fnHello = NULL; void *ValueVoidPtr = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'ValueVoidPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *pValueVoidPtr = NULL; +// CHECK-FIXES: void *pValueVoidPtr = NULL; ptrdiff_t PtrDiff = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'PtrDiff' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ptrdiff_t pPtrDiff = NULL; +// CHECK-FIXES: ptrdiff_t pPtrDiff = NULL; int8_t *ValueI8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global pointer 'ValueI8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t *pi8ValueI8Ptr; +// CHECK-FIXES: int8_t *pi8ValueI8Ptr; uint8_t *ValueU8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global pointer 'ValueU8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t *pu8ValueU8Ptr; +// CHECK-FIXES: uint8_t *pu8ValueU8Ptr; unsigned char *ValueUcPtr; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'ValueUcPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char *pucValueUcPtr; +// CHECK-FIXES: unsigned char *pucValueUcPtr; unsigned char **ValueUcPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global pointer 'ValueUcPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char **ppucValueUcPtr2; +// CHECK-FIXES: unsigned char **ppucValueUcPtr2; void MyFunc2(void* Val){} // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for pointer parameter 'Val' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void MyFunc2(void* pVal){} +// CHECK-FIXES: void MyFunc2(void* pVal){} //===----------------------------------------------------------------------===// @@ -379,16 +379,16 @@ void MyFunc2(void* Val){} int iValueIndex = 1; int &RefValueIndex = iValueIndex; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'RefValueIndex' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int &iRefValueIndex = iValueIndex; +// CHECK-FIXES: int &iRefValueIndex = iValueIndex; const int &ConstRefValue = iValueIndex; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ConstRefValue' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int &iConstRefValue = iValueIndex; +// CHECK-FIXES: const int &iConstRefValue = iValueIndex; long long llValueLongLong = 2; long long &RefValueLongLong = llValueLongLong; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'RefValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long &llRefValueLongLong = llValueLongLong; +// CHECK-FIXES: long long &llRefValueLongLong = llValueLongLong; //===----------------------------------------------------------------------===// @@ -396,151 +396,151 @@ long long &RefValueLongLong = llValueLongLong; //===----------------------------------------------------------------------===// int8_t ValueI8; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t i8ValueI8; +// CHECK-FIXES: int8_t i8ValueI8; int16_t ValueI16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int16_t i16ValueI16 = 0; +// CHECK-FIXES: int16_t i16ValueI16 = 0; int32_t ValueI32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int32_t i32ValueI32 = 0; +// CHECK-FIXES: int32_t i32ValueI32 = 0; int64_t ValueI64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int64_t i64ValueI64 = 0; +// CHECK-FIXES: int64_t i64ValueI64 = 0; uint8_t ValueU8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueU8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t u8ValueU8 = 0; +// CHECK-FIXES: uint8_t u8ValueU8 = 0; uint16_t ValueU16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint16_t u16ValueU16 = 0; +// CHECK-FIXES: uint16_t u16ValueU16 = 0; uint32_t ValueU32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint32_t u32ValueU32 = 0; +// CHECK-FIXES: uint32_t u32ValueU32 = 0; uint64_t ValueU64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint64_t u64ValueU64 = 0; +// CHECK-FIXES: uint64_t u64ValueU64 = 0; float ValueFloat = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming] -// CHECK-FIXES: {{^}}float fValueFloat = 0; +// CHECK-FIXES: float fValueFloat = 0; double ValueDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}double dValueDouble = 0; +// CHECK-FIXES: double dValueDouble = 0; char ValueChar = 'c'; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}char cValueChar = 'c'; +// CHECK-FIXES: char cValueChar = 'c'; bool ValueBool = true; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}bool bValueBool = true; +// CHECK-FIXES: bool bValueBool = true; int ValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iValueInt = 0; +// CHECK-FIXES: int iValueInt = 0; size_t ValueSize = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSize' [readability-identifier-naming] -// CHECK-FIXES: {{^}}size_t nValueSize = 0; +// CHECK-FIXES: size_t nValueSize = 0; wchar_t ValueWchar = 'w'; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueWchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}wchar_t wcValueWchar = 'w'; +// CHECK-FIXES: wchar_t wcValueWchar = 'w'; short ValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}short sValueShort = 0; +// CHECK-FIXES: short sValueShort = 0; unsigned ValueUnsigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned uValueUnsigned = 0; +// CHECK-FIXES: unsigned uValueUnsigned = 0; signed ValueSigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed sValueSigned = 0; +// CHECK-FIXES: signed sValueSigned = 0; long ValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long lValueLong = 0; +// CHECK-FIXES: long lValueLong = 0; long long ValueLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'ValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long llValueLongLong = 0; +// CHECK-FIXES: long long llValueLongLong = 0; long long int ValueLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long int lliValueLongLongInt = 0; +// CHECK-FIXES: long long int lliValueLongLongInt = 0; long double ValueLongDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueLongDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long double ldValueLongDouble = 0; +// CHECK-FIXES: long double ldValueLongDouble = 0; signed int ValueSignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ValueSignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed int siValueSignedInt = 0; +// CHECK-FIXES: signed int siValueSignedInt = 0; signed short ValueSignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueSignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short ssValueSignedShort = 0; +// CHECK-FIXES: signed short ssValueSignedShort = 0; signed short int ValueSignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short int ssiValueSignedShortInt = 0; +// CHECK-FIXES: signed short int ssiValueSignedShortInt = 0; signed long long ValueSignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long long sllValueSignedLongLong = 0; +// CHECK-FIXES: signed long long sllValueSignedLongLong = 0; signed long int ValueSignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global variable 'ValueSignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long int sliValueSignedLongInt = 0; +// CHECK-FIXES: signed long int sliValueSignedLongInt = 0; signed long ValueSignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueSignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long slValueSignedLong = 0; +// CHECK-FIXES: signed long slValueSignedLong = 0; unsigned long long int ValueUnsignedLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for global variable 'ValueUnsignedLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long int ulliValueUnsignedLongLongInt = 0; +// CHECK-FIXES: unsigned long long int ulliValueUnsignedLongLongInt = 0; unsigned long long ValueUnsignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long ullValueUnsignedLongLong = 0; +// CHECK-FIXES: unsigned long long ullValueUnsignedLongLong = 0; unsigned long int ValueUnsignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for global variable 'ValueUnsignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long int uliValueUnsignedLongInt = 0; +// CHECK-FIXES: unsigned long int uliValueUnsignedLongInt = 0; unsigned long ValueUnsignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long ulValueUnsignedLong = 0; +// CHECK-FIXES: unsigned long ulValueUnsignedLong = 0; unsigned short int ValueUnsignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short int usiValueUnsignedShortInt = 0; +// CHECK-FIXES: unsigned short int usiValueUnsignedShortInt = 0; unsigned short ValueUnsignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'ValueUnsignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short usValueUnsignedShort = 0; +// CHECK-FIXES: unsigned short usValueUnsignedShort = 0; unsigned int ValueUnsignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueUnsignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned int uiValueUnsignedInt = 0; +// CHECK-FIXES: unsigned int uiValueUnsignedInt = 0; unsigned char ValueUnsignedChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char ucValueUnsignedChar = 0; +// CHECK-FIXES: unsigned char ucValueUnsignedChar = 0; long int ValueLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long int liValueLongInt = 0; +// CHECK-FIXES: long int liValueLongInt = 0; //===----------------------------------------------------------------------===// @@ -548,25 +548,25 @@ long int ValueLongInt = 0; //===----------------------------------------------------------------------===// volatile int VolatileInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}volatile int iVolatileInt = 0; +// CHECK-FIXES: volatile int iVolatileInt = 0; thread_local int ThreadLocalValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ThreadLocalValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}thread_local int iThreadLocalValueInt = 0; +// CHECK-FIXES: thread_local int iThreadLocalValueInt = 0; extern int ExternValueInt; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}extern int iExternValueInt; +// CHECK-FIXES: extern int iExternValueInt; struct DataBuffer { mutable size_t Size; }; // CHECK-MESSAGES: :[[@LINE-2]]:20: warning: invalid case style for public member 'Size' [readability-identifier-naming] -// CHECK-FIXES: {{^}} mutable size_t nSize; +// CHECK-FIXES: mutable size_t nSize; static constexpr int const &ConstExprInt = 42; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: invalid case style for constexpr variable 'ConstExprInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static constexpr int const &iConstExprInt = 42; +// CHECK-FIXES: static constexpr int const &iConstExprInt = 42; //===----------------------------------------------------------------------===// @@ -575,7 +575,7 @@ static constexpr int const &ConstExprInt = 42; typedef int INDEX; INDEX iIndex = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'iIndex' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INDEX Index = 0; +// CHECK-FIXES: INDEX Index = 0; //===----------------------------------------------------------------------===// @@ -583,96 +583,96 @@ INDEX iIndex = 0; //===----------------------------------------------------------------------===// class ClassCase { int Func(); }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class CClassCase { int Func(); }; +// CHECK-FIXES: class CClassCase { int Func(); }; class AbstractClassCase { virtual int Func() = 0; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClassCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class IAbstractClassCase { virtual int Func() = 0; }; +// CHECK-FIXES: class IAbstractClassCase { virtual int Func() = 0; }; class AbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClassCase1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class IAbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; +// CHECK-FIXES: class IAbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; class ClassConstantCase { public: static const int iConstantCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class CClassConstantCase { public: static const int iConstantCase; }; +// CHECK-FIXES: class CClassConstantCase { public: static const int iConstantCase; }; //===----------------------------------------------------------------------===// // Other Cases //===----------------------------------------------------------------------===// int lower_case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iLowerCase = 0; +// CHECK-FIXES: int iLowerCase = 0; int lower_case1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iLowerCase1 = 0; +// CHECK-FIXES: int iLowerCase1 = 0; int lower_case_2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case_2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iLowerCase2 = 0; +// CHECK-FIXES: int iLowerCase2 = 0; int UPPER_CASE = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iUpperCase = 0; +// CHECK-FIXES: int iUpperCase = 0; int UPPER_CASE_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iUpperCase1 = 0; +// CHECK-FIXES: int iUpperCase1 = 0; int camelBack = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelBack = 0; +// CHECK-FIXES: int iCamelBack = 0; int camelBack_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelBack1 = 0; +// CHECK-FIXES: int iCamelBack1 = 0; int camelBack2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelBack2 = 0; +// CHECK-FIXES: int iCamelBack2 = 0; int CamelCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelCase = 0; +// CHECK-FIXES: int iCamelCase = 0; int CamelCase_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelCase1 = 0; +// CHECK-FIXES: int iCamelCase1 = 0; int CamelCase2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelCase2 = 0; +// CHECK-FIXES: int iCamelCase2 = 0; int camel_Snake_Back = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeBack = 0; +// CHECK-FIXES: int iCamelSnakeBack = 0; int camel_Snake_Back_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeBack1 = 0; +// CHECK-FIXES: int iCamelSnakeBack1 = 0; int Camel_Snake_Case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeCase = 0; +// CHECK-FIXES: int iCamelSnakeCase = 0; int Camel_Snake_Case_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int iCamelSnakeCase1 = 0; +// CHECK-FIXES: int iCamelSnakeCase1 = 0; //===----------------------------------------------------------------------===// // Enum //===----------------------------------------------------------------------===// enum REV_TYPE { RevValid }; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for enum constant 'RevValid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum REV_TYPE { rtRevValid }; +// CHECK-FIXES: enum REV_TYPE { rtRevValid }; enum EnumConstantCase { OneByte, TwoByte }; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for enum constant 'OneByte' [readability-identifier-naming] // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: invalid case style for enum constant 'TwoByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum EnumConstantCase { eccOneByte, eccTwoByte }; +// CHECK-FIXES: enum EnumConstantCase { eccOneByte, eccTwoByte }; enum class ScopedEnumConstantCase { Case1 }; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: invalid case style for scoped enum constant 'Case1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}enum class ScopedEnumConstantCase { seccCase1 }; +// CHECK-FIXES: enum class ScopedEnumConstantCase { seccCase1 }; // clang-format on diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-ignored-regexp.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-ignored-regexp.cpp index a39b6f1..32e67594 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-ignored-regexp.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-ignored-regexp.cpp @@ -13,11 +13,11 @@ int testFunc(int ab, char **ba); int testFunc(int abc, char **cba); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'abc' // CHECK-MESSAGES: :[[@LINE-2]]:30: warning: invalid case style for parameter 'cba' -// CHECK-FIXES: {{^}}int testFunc(int Abc, char **Cba);{{$}} +// CHECK-FIXES: int testFunc(int Abc, char **Cba); int testFunc(int dE, char **eD); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'dE' // CHECK-MESSAGES: :[[@LINE-2]]:29: warning: invalid case style for parameter 'eD' -// CHECK-FIXES: {{^}}int testFunc(int DE, char **ED);{{$}} +// CHECK-FIXES: int testFunc(int DE, char **ED); int testFunc(int Abc, char **Cba); class fo { @@ -25,12 +25,12 @@ class fo { class fofo { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'fofo' - // CHECK-FIXES: {{^}}class Fofo {{{$}} + // CHECK-FIXES: class Fofo { }; class foo { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'foo' - // CHECK-FIXES: {{^}}class Foo {{{$}} + // CHECK-FIXES: class Foo { }; class fooo { @@ -38,10 +38,10 @@ class fooo { class afooo { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'afooo' - // CHECK-FIXES: {{^}}class Afooo {{{$}} + // CHECK-FIXES: class Afooo { }; struct soo { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'soo' - // CHECK-FIXES: {{^}}struct Soo {{{$}} + // CHECK-FIXES: struct Soo { }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-member-decl-usage.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-member-decl-usage.cpp index 291195e..61c3aeb 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-member-decl-usage.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-member-decl-usage.cpp @@ -13,41 +13,41 @@ class Foo { public: const int bar_baz; // comment-0 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for member 'bar_baz' - // CHECK-FIXES: {{^}} const int BarBaz; // comment-0 + // CHECK-FIXES: const int BarBaz; // comment-0 Foo(int Val) : bar_baz(Val) { // comment-1 - // CHECK-FIXES: {{^}} Foo(int Val) : BarBaz(Val) { // comment-1 + // CHECK-FIXES: Foo(int Val) : BarBaz(Val) { // comment-1 set_up(bar_baz); // comment-2 - // CHECK-FIXES: {{^}} set_up(BarBaz); // comment-2 + // CHECK-FIXES: set_up(BarBaz); // comment-2 } Foo() : Foo(0) {} ~Foo() { clear(bar_baz); // comment-3 - // CHECK-FIXES: {{^}} clear(BarBaz); // comment-3 + // CHECK-FIXES: clear(BarBaz); // comment-3 } int getBar() const { return bar_baz; } // comment-4 - // CHECK-FIXES: {{^}} int getBar() const { return BarBaz; } // comment-4 + // CHECK-FIXES: int getBar() const { return BarBaz; } // comment-4 }; class FooBar : public Foo { public: int getFancyBar() const { return this->bar_baz; // comment-5 - // CHECK-FIXES: {{^}} return this->BarBaz; // comment-5 + // CHECK-FIXES: return this->BarBaz; // comment-5 } }; int getBar(const Foo &Foo) { return Foo.bar_baz; // comment-6 - // CHECK-FIXES: {{^}} return Foo.BarBaz; // comment-6 + // CHECK-FIXES: return Foo.BarBaz; // comment-6 } int getBar(const FooBar &Foobar) { return Foobar.bar_baz; // comment-7 - // CHECK-FIXES: {{^}} return Foobar.BarBaz; // comment-7 + // CHECK-FIXES: return Foobar.BarBaz; // comment-7 } int getFancyBar(const FooBar &Foobar) { @@ -60,9 +60,9 @@ public: TempTest() = default; TempTest(int Val) : Foo(Val) {} int getBar() const { return Foo::bar_baz; } // comment-8 - // CHECK-FIXES: {{^}} int getBar() const { return Foo::BarBaz; } // comment-8 + // CHECK-FIXES: int getBar() const { return Foo::BarBaz; } // comment-8 int getBar2() const { return this->bar_baz; } // comment-9 - // CHECK-FIXES: {{^}} int getBar2() const { return this->BarBaz; } // comment-9 + // CHECK-FIXES: int getBar2() const { return this->BarBaz; } // comment-9 }; namespace Bug41122 { @@ -82,15 +82,15 @@ class Foo { public: Foo(std::vector<bool> &stack) // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for parameter 'stack' [readability-identifier-naming] - // CHECK-FIXES: {{^}} Foo(std::vector<bool> &Stack) + // CHECK-FIXES: Foo(std::vector<bool> &Stack) : stack(stack) { - // CHECK-FIXES: {{^}} : Stack(Stack) { + // CHECK-FIXES: : Stack(Stack) { stack.push_back(true); - // CHECK-FIXES: {{^}} Stack.push_back(true); + // CHECK-FIXES: Stack.push_back(true); } ~Foo() { stack.pop_back(); - // CHECK-FIXES: {{^}} Stack.pop_back(); + // CHECK-FIXES: Stack.pop_back(); } }; }; // namespace Bug41122 @@ -100,13 +100,13 @@ class Foo { public: int a_member_of_foo = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for member 'a_member_of_foo' - // CHECK-FIXES: {{^}} int AMemberOfFoo = 0; + // CHECK-FIXES: int AMemberOfFoo = 0; }; int main() { Foo foo; return foo.a_member_of_foo; - // CHECK-FIXES: {{^}} return foo.AMemberOfFoo; + // CHECK-FIXES: return foo.AMemberOfFoo; } }; // namespace Bug29005 @@ -115,13 +115,13 @@ template <typename T, unsigned N> class Container { T storage[N]; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for member 'storage' - // CHECK-FIXES: {{^}} T Storage[N]; + // CHECK-FIXES: T Storage[N]; T *pointer = &storage[0]; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for member 'pointer' - // CHECK-FIXES: {{^}} T *Pointer = &Storage[0]; + // CHECK-FIXES: T *Pointer = &Storage[0]; public: Container() : pointer(&storage[0]) {} - // CHECK-FIXES: {{^}} Container() : Pointer(&Storage[0]) {} + // CHECK-FIXES: Container() : Pointer(&Storage[0]) {} }; void foo() { @@ -137,8 +137,8 @@ struct A0 { A0 &operator=(const A0 &Other) { value = Other.value; // A0 this->value = Other.value; // A0 - // CHECK-FIXES: {{^}} Value = Other.Value; // A0 - // CHECK-FIXES-NEXT: {{^}} this->Value = Other.Value; // A0 + // CHECK-FIXES: Value = Other.Value; // A0 + // CHECK-FIXES-NEXT: this->Value = Other.Value; // A0 return *this; } void outOfLineReset(); @@ -147,14 +147,14 @@ struct A0 { template <typename T> void A0<T>::outOfLineReset() { this->value -= value; // A0 - // CHECK-FIXES: {{^}} this->Value -= Value; // A0 + // CHECK-FIXES: this->Value -= Value; // A0 } template <typename T> struct A1 { int value; // A1 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for member 'value' - // CHECK-FIXES: {{^}} int Value; // A1 + // CHECK-FIXES: int Value; // A1 int GetValue() const { return value; } // A1 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for method 'GetValue' // CHECK-FIXES {{^}} int getValue() const { return Value; } // A1 @@ -164,8 +164,8 @@ struct A1 { A1 &operator=(const A1 &Other) { this->SetValue(Other.GetValue()); // A1 this->value = Other.value; // A1 - // CHECK-FIXES: {{^}} this->setValue(Other.getValue()); // A1 - // CHECK-FIXES-NEXT: {{^}} this->Value = Other.Value; // A1 + // CHECK-FIXES: this->setValue(Other.getValue()); // A1 + // CHECK-FIXES-NEXT: this->Value = Other.Value; // A1 return *this; } void outOfLineReset(); @@ -174,19 +174,19 @@ struct A1 { template <typename T> void A1<T>::outOfLineReset() { this->value -= value; // A1 - // CHECK-FIXES: {{^}} this->Value -= Value; // A1 + // CHECK-FIXES: this->Value -= Value; // A1 } template <unsigned T> struct A2 { int value; // A2 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for member 'value' - // CHECK-FIXES: {{^}} int Value; // A2 + // CHECK-FIXES: int Value; // A2 A2 &operator=(const A2 &Other) { value = Other.value; // A2 this->value = Other.value; // A2 - // CHECK-FIXES: {{^}} Value = Other.Value; // A2 - // CHECK-FIXES-NEXT: {{^}} this->Value = Other.Value; // A2 + // CHECK-FIXES: Value = Other.Value; // A2 + // CHECK-FIXES-NEXT: this->Value = Other.Value; // A2 return *this; } }; @@ -203,14 +203,14 @@ template <typename T> struct DependentBase { int depValue; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for member 'depValue' - // CHECK-FIXES: {{^}} int DepValue; + // CHECK-FIXES: int DepValue; }; template <typename T> struct Derived : DependentBase<T> { Derived &operator=(const Derived &Other) { this->depValue = Other.depValue; - // CHECK-FIXES: {{^}} this->DepValue = Other.DepValue; + // CHECK-FIXES: this->DepValue = Other.DepValue; return *this; } }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming.cpp index 1771836..8650275 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming.cpp @@ -96,14 +96,14 @@ namespace FOO_NS { // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for namespace 'FOO_NS' [readability-identifier-naming] -// CHECK-FIXES: {{^}}namespace foo_ns {{{$}} +// CHECK-FIXES: namespace foo_ns { inline namespace InlineNamespace { // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for inline namespace 'InlineNamespace' -// CHECK-FIXES: {{^}}inline namespace inline_namespace {{{$}} +// CHECK-FIXES: inline namespace inline_namespace { namespace FOO_ALIAS = FOO_NS; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for namespace 'FOO_ALIAS' [readability-identifier-naming] -// CHECK-FIXES: {{^}}namespace foo_alias = FOO_NS;{{$}} +// CHECK-FIXES: namespace foo_alias = FOO_NS; SYSTEM_NS::structure g_s1; // NO warnings or fixes expected as SYSTEM_NS and structure are declared in a header file @@ -113,11 +113,11 @@ USER_NS::object g_s2; SYSTEM_MACRO(var1); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'var1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}SYSTEM_MACRO(g_var1); +// CHECK-FIXES: SYSTEM_MACRO(g_var1); USER_MACRO(var2); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'var2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}USER_MACRO(g_var2); +// CHECK-FIXES: USER_MACRO(g_var2); #define BLA int FOO_bar BLA; @@ -144,116 +144,116 @@ USE_RECONSTRUCTED(glo, bal2); int global; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'global' -// CHECK-FIXES: {{^}}int g_global;{{$}} +// CHECK-FIXES: int g_global; #define USE_IN_MACRO(m) auto use_##m = m USE_IN_MACRO(global); int global3; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'global3' -// CHECK-FIXES: {{^}}int g_global3;{{$}} +// CHECK-FIXES: int g_global3; #define ADD_TO_SELF(m) (m) + (m) int g_twice_global3 = ADD_TO_SELF(global3); -// CHECK-FIXES: {{^}}int g_twice_global3 = ADD_TO_SELF(g_global3);{{$}} +// CHECK-FIXES: int g_twice_global3 = ADD_TO_SELF(g_global3); int g_Global4; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'g_Global4' -// CHECK-FIXES: {{^}}int g_global4;{{$}} +// CHECK-FIXES: int g_global4; enum my_enumeration { // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for enum 'my_enumeration' -// CHECK-FIXES: {{^}}enum EMyEnumeration {{{$}} +// CHECK-FIXES: enum EMyEnumeration { MyConstant = 1, // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'MyConstant' -// CHECK-FIXES: {{^}} MY_CONSTANT = 1,{{$}} +// CHECK-FIXES: MY_CONSTANT = 1, your_CONST = 1, // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'your_CONST' -// CHECK-FIXES: {{^}} YOUR_CONST = 1,{{$}} +// CHECK-FIXES: YOUR_CONST = 1, THIS_ConstValue = 1, // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'THIS_ConstValue' -// CHECK-FIXES: {{^}} THIS_CONST_VALUE = 1,{{$}} +// CHECK-FIXES: THIS_CONST_VALUE = 1, }; enum class EMyEnumeration { myConstant = 1, // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'myConstant' -// CHECK-FIXES: {{^}} MyConstant = 1,{{$}} +// CHECK-FIXES: MyConstant = 1, your_CONST = 1, // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'your_CONST' -// CHECK-FIXES: {{^}} YourConst = 1,{{$}} +// CHECK-FIXES: YourConst = 1, THIS_ConstValue = 1, // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'THIS_ConstValue' -// CHECK-FIXES: {{^}} ThisConstValue = 1,{{$}} +// CHECK-FIXES: ThisConstValue = 1, }; constexpr int ConstExpr_variable = MyConstant; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constexpr variable 'ConstExpr_variable' -// CHECK-FIXES: {{^}}constexpr int const_expr_variable = MY_CONSTANT;{{$}} +// CHECK-FIXES: constexpr int const_expr_variable = MY_CONSTANT; class my_class { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_class' -// CHECK-FIXES: {{^}}class CMyClass {{{$}} +// CHECK-FIXES: class CMyClass { public: my_class(); -// CHECK-FIXES: {{^}} CMyClass();{{$}} +// CHECK-FIXES: CMyClass(); my_class(void*) : my_class() {} -// CHECK-FIXES: {{^}} CMyClass(void*) : CMyClass() {}{{$}} +// CHECK-FIXES: CMyClass(void*) : CMyClass() {} ~ my_class(); // (space in destructor token test, we could check trigraph but they will be deprecated) -// CHECK-FIXES: {{^}} ~{{$}} -// CHECK-FIXES: {{^}} CMyClass();{{$}} +// CHECK-FIXES: ~ +// CHECK-FIXES: CMyClass(); private: const int MEMBER_one_1 = ConstExpr_variable; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for constant member 'MEMBER_one_1' -// CHECK-FIXES: {{^}} const int member_one_1 = const_expr_variable;{{$}} +// CHECK-FIXES: const int member_one_1 = const_expr_variable; int member2 = 2; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member 'member2' -// CHECK-FIXES: {{^}} int __member2 = 2;{{$}} +// CHECK-FIXES: int __member2 = 2; int _memberWithExtraUnderscores_ = 42; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member '_memberWithExtraUnderscores_' -// CHECK-FIXES: {{^}} int __memberWithExtraUnderscores = 42;{{$}} +// CHECK-FIXES: int __memberWithExtraUnderscores = 42; private: int private_member = 3; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'private_member' -// CHECK-FIXES: {{^}} int __private_member = 3;{{$}} +// CHECK-FIXES: int __private_member = 3; protected: int ProtMember; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for protected member 'ProtMember' -// CHECK-FIXES: {{^}} int _ProtMember;{{$}} +// CHECK-FIXES: int _ProtMember; public: int PubMem; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for public member 'PubMem' -// CHECK-FIXES: {{^}} int pub_mem;{{$}} +// CHECK-FIXES: int pub_mem; static const int classConstant; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: invalid case style for class constant 'classConstant' -// CHECK-FIXES: {{^}} static const int kClassConstant;{{$}} +// CHECK-FIXES: static const int kClassConstant; static int ClassMember_2; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for class member 'ClassMember_2' -// CHECK-FIXES: {{^}} static int ClassMember2;{{$}} +// CHECK-FIXES: static int ClassMember2; }; class my_class; // No warning needed here as this is tied to the previous declaration. // Just make sure the fix is applied. -// CHECK-FIXES: {{^}}class CMyClass;{{$}} +// CHECK-FIXES: class CMyClass; class my_forward_declared_class; // No warning should be triggered. const int my_class::classConstant = 4; -// CHECK-FIXES: {{^}}const int CMyClass::kClassConstant = 4;{{$}} +// CHECK-FIXES: const int CMyClass::kClassConstant = 4; int my_class::ClassMember_2 = 5; -// CHECK-FIXES: {{^}}int CMyClass::ClassMember2 = 5;{{$}} +// CHECK-FIXES: int CMyClass::ClassMember2 = 5; class my_derived_class : public virtual my_class {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_derived_class' -// CHECK-FIXES: {{^}}class CMyDerivedClass : public virtual CMyClass {};{{$}} +// CHECK-FIXES: class CMyDerivedClass : public virtual CMyClass {}; class CMyWellNamedClass {}; // No warning expected as this class is well named. @@ -265,26 +265,26 @@ concept MyConcept = requires (t_t a_t) { {a_t++}; }; template<typename t_t> concept my_concept_2 = requires (t_t a_t) { {a_t++}; }; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for concept 'my_concept_2' -// CHECK-FIXES: {{^}}concept MyConcept2 = requires (t_t a_t) { {a_t++}; };{{$}} +// CHECK-FIXES: concept MyConcept2 = requires (t_t a_t) { {a_t++}; }; template <typename t_t> class CMyWellNamedClass2 : public my_class { - // CHECK-FIXES: {{^}}class CMyWellNamedClass2 : public CMyClass {{{$}} + // CHECK-FIXES: class CMyWellNamedClass2 : public CMyClass { t_t my_Bad_Member; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member 'my_Bad_Member' - // CHECK-FIXES: {{^}} t_t __my_Bad_Member;{{$}} + // CHECK-FIXES: t_t __my_Bad_Member; int my_Other_Bad_Member = 42; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member 'my_Other_Bad_Member' - // CHECK-FIXES: {{^}} int __my_Other_Bad_Member = 42;{{$}} + // CHECK-FIXES: int __my_Other_Bad_Member = 42; public: CMyWellNamedClass2() = default; CMyWellNamedClass2(CMyWellNamedClass2 const&) = default; CMyWellNamedClass2(CMyWellNamedClass2 &&) = default; CMyWellNamedClass2(t_t a_v, void *p_p) : my_class(p_p), my_Bad_Member(a_v) {} - // CHECK-FIXES: {{^}} CMyWellNamedClass2(t_t a_v, void *p_p) : CMyClass(p_p), __my_Bad_Member(a_v) {}{{$}} + // CHECK-FIXES: CMyWellNamedClass2(t_t a_v, void *p_p) : CMyClass(p_p), __my_Bad_Member(a_v) {} CMyWellNamedClass2(t_t a_v) : my_class(), my_Bad_Member(a_v), my_Other_Bad_Member(11) {} - // CHECK-FIXES: {{^}} CMyWellNamedClass2(t_t a_v) : CMyClass(), __my_Bad_Member(a_v), __my_Other_Bad_Member(11) {}{{$}} + // CHECK-FIXES: CMyWellNamedClass2(t_t a_v) : CMyClass(), __my_Bad_Member(a_v), __my_Other_Bad_Member(11) {} }; void InstantiateClassMethods() { // Ensure we trigger the instantiation of each constructor @@ -300,40 +300,40 @@ public: virtual ~AOverridden() = default; virtual void BadBaseMethod() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethod' - // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method() = 0; + // CHECK-FIXES: virtual void v_Bad_Base_Method() = 0; virtual void BadBaseMethodNoAttr() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethodNoAttr' - // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method_No_Attr() = 0; + // CHECK-FIXES: virtual void v_Bad_Base_Method_No_Attr() = 0; }; class COverriding : public AOverridden { public: // Overriding a badly-named base isn't a new violation. void BadBaseMethod() override {} - // CHECK-FIXES: {{^}} void v_Bad_Base_Method() override {} + // CHECK-FIXES: void v_Bad_Base_Method() override {} void BadBaseMethodNoAttr() /* override */ {} - // CHECK-FIXES: {{^}} void v_Bad_Base_Method_No_Attr() /* override */ {} + // CHECK-FIXES: void v_Bad_Base_Method_No_Attr() /* override */ {} void foo() { BadBaseMethod(); - // CHECK-FIXES: {{^}} v_Bad_Base_Method(); + // CHECK-FIXES: v_Bad_Base_Method(); this->BadBaseMethod(); - // CHECK-FIXES: {{^}} this->v_Bad_Base_Method(); + // CHECK-FIXES: this->v_Bad_Base_Method(); AOverridden::BadBaseMethod(); - // CHECK-FIXES: {{^}} AOverridden::v_Bad_Base_Method(); + // CHECK-FIXES: AOverridden::v_Bad_Base_Method(); COverriding::BadBaseMethod(); - // CHECK-FIXES: {{^}} COverriding::v_Bad_Base_Method(); + // CHECK-FIXES: COverriding::v_Bad_Base_Method(); BadBaseMethodNoAttr(); - // CHECK-FIXES: {{^}} v_Bad_Base_Method_No_Attr(); + // CHECK-FIXES: v_Bad_Base_Method_No_Attr(); this->BadBaseMethodNoAttr(); - // CHECK-FIXES: {{^}} this->v_Bad_Base_Method_No_Attr(); + // CHECK-FIXES: this->v_Bad_Base_Method_No_Attr(); AOverridden::BadBaseMethodNoAttr(); - // CHECK-FIXES: {{^}} AOverridden::v_Bad_Base_Method_No_Attr(); + // CHECK-FIXES: AOverridden::v_Bad_Base_Method_No_Attr(); COverriding::BadBaseMethodNoAttr(); - // CHECK-FIXES: {{^}} COverriding::v_Bad_Base_Method_No_Attr(); + // CHECK-FIXES: COverriding::v_Bad_Base_Method_No_Attr(); } }; @@ -343,11 +343,11 @@ class ATOverridden { public: virtual void BadBaseMethod() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethod' - // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method() = 0; + // CHECK-FIXES: virtual void v_Bad_Base_Method() = 0; virtual void BadBaseMethodNoAttr() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethodNoAttr' - // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method_No_Attr() = 0; + // CHECK-FIXES: virtual void v_Bad_Base_Method_No_Attr() = 0; }; template<typename some_t> @@ -361,13 +361,13 @@ class CTOverriding : public ATOverridden<some_t> { // known whether this method overrides anything, so we get the warning here. virtual void BadBaseMethodNoAttr() {}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethodNoAttr' - // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method_No_Attr() {}; + // CHECK-FIXES: virtual void v_Bad_Base_Method_No_Attr() {}; }; template<typename some_t> void VirtualCall(AOverridden &a_vItem, ATOverridden<some_t> &a_vTitem) { a_vItem.BadBaseMethod(); - // CHECK-FIXES: {{^}} a_vItem.v_Bad_Base_Method(); + // CHECK-FIXES: a_vItem.v_Bad_Base_Method(); // FIXME: The fixes from ATOverridden should be propagated to the following call a_vTitem.BadBaseMethod(); @@ -379,7 +379,7 @@ class ATIOverridden { public: virtual void BadBaseMethod() = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethod' - // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method() = 0; + // CHECK-FIXES: virtual void v_Bad_Base_Method() = 0; }; template<typename some_t> @@ -387,17 +387,17 @@ class CTIOverriding : public ATIOverridden<some_t> { public: // Overriding a badly-named base isn't a new violation. void BadBaseMethod() override {} - // CHECK-FIXES: {{^}} void v_Bad_Base_Method() override {} + // CHECK-FIXES: void v_Bad_Base_Method() override {} }; template class CTIOverriding<int>; void VirtualCallI(ATIOverridden<int>& a_vItem, CTIOverriding<int>& a_vCitem) { a_vItem.BadBaseMethod(); - // CHECK-FIXES: {{^}} a_vItem.v_Bad_Base_Method(); + // CHECK-FIXES: a_vItem.v_Bad_Base_Method(); a_vCitem.BadBaseMethod(); - // CHECK-FIXES: {{^}} a_vCitem.v_Bad_Base_Method(); + // CHECK-FIXES: a_vCitem.v_Bad_Base_Method(); } template <typename derived_t> @@ -415,51 +415,51 @@ public: template<typename T> // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for type template parameter 'T' -// CHECK-FIXES: {{^}}template<typename t_t>{{$}} +// CHECK-FIXES: template<typename t_t> class my_templated_class : CMyWellNamedClass {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_templated_class' -// CHECK-FIXES: {{^}}class CMyTemplatedClass : CMyWellNamedClass {};{{$}} +// CHECK-FIXES: class CMyTemplatedClass : CMyWellNamedClass {}; template<typename T> // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for type template parameter 'T' -// CHECK-FIXES: {{^}}template<typename t_t>{{$}} +// CHECK-FIXES: template<typename t_t> class my_other_templated_class : my_templated_class< my_class>, private my_derived_class {}; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_other_templated_class' -// CHECK-FIXES: {{^}}class CMyOtherTemplatedClass : CMyTemplatedClass< CMyClass>, private CMyDerivedClass {};{{$}} +// CHECK-FIXES: class CMyOtherTemplatedClass : CMyTemplatedClass< CMyClass>, private CMyDerivedClass {}; template<typename t_t> using mysuper_tpl_t = my_other_templated_class <:: FOO_NS ::my_class>; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'mysuper_tpl_t' -// CHECK-FIXES: {{^}}using mysuper_Tpl_t = CMyOtherTemplatedClass <:: foo_ns ::CMyClass>;{{$}} +// CHECK-FIXES: using mysuper_Tpl_t = CMyOtherTemplatedClass <:: foo_ns ::CMyClass>; const int global_Constant = 6; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'global_Constant' -// CHECK-FIXES: {{^}}const int GLOBAL_CONSTANT = 6;{{$}} +// CHECK-FIXES: const int GLOBAL_CONSTANT = 6; int Global_variable = 7; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Global_variable' -// CHECK-FIXES: {{^}}int g_global_variable = 7;{{$}} +// CHECK-FIXES: int g_global_variable = 7; void global_function(int PARAMETER_1, int const CONST_parameter) { // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global function 'global_function' // CHECK-MESSAGES: :[[@LINE-2]]:26: warning: invalid case style for parameter 'PARAMETER_1' // CHECK-MESSAGES: :[[@LINE-3]]:49: warning: invalid case style for constant parameter 'CONST_parameter' -// CHECK-FIXES: {{^}}void GlobalFunction(int a_parameter1, int const i_constParameter) {{{$}} +// CHECK-FIXES: void GlobalFunction(int a_parameter1, int const i_constParameter) { static const int THIS_static_ConsTant = 4; // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: invalid case style for static constant 'THIS_static_ConsTant' -// CHECK-FIXES: {{^}} static const int THIS_STATIC_CONS_TANT = 4;{{$}} +// CHECK-FIXES: static const int THIS_STATIC_CONS_TANT = 4; static int THIS_static_variable; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for static variable 'THIS_static_variable' -// CHECK-FIXES: {{^}} static int s_thisStaticVariable;{{$}} +// CHECK-FIXES: static int s_thisStaticVariable; int const local_Constant = 3; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for local constant 'local_Constant' -// CHECK-FIXES: {{^}} int const kLocalConstant = 3;{{$}} +// CHECK-FIXES: int const kLocalConstant = 3; int LOCAL_VARIABLE; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for local variable 'LOCAL_VARIABLE' -// CHECK-FIXES: {{^}} int local_variable;{{$}} +// CHECK-FIXES: int local_variable; int LOCAL_Array__[] = {0, 1, 2}; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for local variable 'LOCAL_Array__' -// CHECK-FIXES: {{^}} int local_array[] = {0, 1, 2};{{$}} +// CHECK-FIXES: int local_array[] = {0, 1, 2}; for (auto _ : LOCAL_Array__) { } @@ -467,15 +467,15 @@ void global_function(int PARAMETER_1, int const CONST_parameter) { template<typename ... TYPE_parameters> // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for type template parameter 'TYPE_parameters' -// CHECK-FIXES: {{^}}template<typename ... typeParameters_t>{{$}} +// CHECK-FIXES: template<typename ... typeParameters_t> void Global_Fun(TYPE_parameters... PARAMETER_PACK) { // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global function 'Global_Fun' // CHECK-MESSAGES: :[[@LINE-2]]:36: warning: invalid case style for parameter pack 'PARAMETER_PACK' -// CHECK-FIXES: {{^}}void GlobalFun(typeParameters_t... parameterPack) {{{$}} +// CHECK-FIXES: void GlobalFun(typeParameters_t... parameterPack) { global_function(1, 2); -// CHECK-FIXES: {{^}} GlobalFunction(1, 2);{{$}} +// CHECK-FIXES: GlobalFunction(1, 2); FOO_bar = Global_variable; -// CHECK-FIXES: {{^}} FOO_bar = g_global_variable;{{$}} +// CHECK-FIXES: FOO_bar = g_global_variable; // NO fix expected for FOO_bar declared in macro expansion } @@ -483,134 +483,134 @@ template<template<typename> class TPL_parameter, int COUNT_params, typename ... // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: invalid case style for template template parameter 'TPL_parameter' // CHECK-MESSAGES: :[[@LINE-2]]:54: warning: invalid case style for value template parameter 'COUNT_params' // CHECK-MESSAGES: :[[@LINE-3]]:81: warning: invalid case style for type template parameter 'TYPE_parameters' -// CHECK-FIXES: {{^}}template<template<typename> class TplParameter, int countParams, typename ... typeParameters_t>{{$}} +// CHECK-FIXES: template<template<typename> class TplParameter, int countParams, typename ... typeParameters_t> class test_CLASS { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'test_CLASS' -// CHECK-FIXES: {{^}}class CTestClass {{{$}} +// CHECK-FIXES: class CTestClass { }; class abstract_class { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'abstract_class' -// CHECK-FIXES: {{^}}class AAbstractClass {{{$}} +// CHECK-FIXES: class AAbstractClass { virtual ~abstract_class() = 0; -// CHECK-FIXES: {{^}} virtual ~AAbstractClass() = 0;{{$}} +// CHECK-FIXES: virtual ~AAbstractClass() = 0; virtual void VIRTUAL_METHOD(); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for virtual method 'VIRTUAL_METHOD' -// CHECK-FIXES: {{^}} virtual void v_Virtual_Method();{{$}} +// CHECK-FIXES: virtual void v_Virtual_Method(); void non_Virtual_METHOD() {} // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for private method 'non_Virtual_METHOD' -// CHECK-FIXES: {{^}} void __non_Virtual_METHOD() {}{{$}} +// CHECK-FIXES: void __non_Virtual_METHOD() {} public: static void CLASS_METHOD() {} // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for class method 'CLASS_METHOD' -// CHECK-FIXES: {{^}} static void classMethod() {}{{$}} +// CHECK-FIXES: static void classMethod() {} constexpr int CST_expr_Method() { return 2; } // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for constexpr method 'CST_expr_Method' -// CHECK-FIXES: {{^}} constexpr int cst_expr_method() { return 2; }{{$}} +// CHECK-FIXES: constexpr int cst_expr_method() { return 2; } private: void PRIVate_Method(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for private method 'PRIVate_Method' -// CHECK-FIXES: {{^}} void __PRIVate_Method();{{$}} +// CHECK-FIXES: void __PRIVate_Method(); protected: void protected_Method(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for protected method 'protected_Method' -// CHECK-FIXES: {{^}} void _protected_Method();{{$}} +// CHECK-FIXES: void _protected_Method(); public: void public_Method(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for method 'public_Method' -// CHECK-FIXES: {{^}} void publicMethod();{{$}} +// CHECK-FIXES: void publicMethod(); }; constexpr int CE_function() { return 3; } // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constexpr function 'CE_function' -// CHECK-FIXES: {{^}}constexpr int ce_function() { return 3; }{{$}} +// CHECK-FIXES: constexpr int ce_function() { return 3; } struct THIS___Structure { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'THIS___Structure' -// CHECK-FIXES: {{^}}struct This_structure {{{$}} +// CHECK-FIXES: struct This_structure { THIS___Structure(); -// CHECK-FIXES: {{^}} This_structure();{{$}} +// CHECK-FIXES: This_structure(); union __MyUnion_is_wonderful__ {}; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for union '__MyUnion_is_wonderful__' -// CHECK-FIXES: {{^}} union UMyUnionIsWonderful {};{{$}} +// CHECK-FIXES: union UMyUnionIsWonderful {}; }; typedef THIS___Structure struct_type; // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for typedef 'struct_type' -// CHECK-FIXES: {{^}}typedef This_structure struct_type_t;{{$}} +// CHECK-FIXES: typedef This_structure struct_type_t; struct_type GlobalTypedefTestFunction(struct_type a_argument1) { -// CHECK-FIXES: {{^}}struct_type_t GlobalTypedefTestFunction(struct_type_t a_argument1) { +// CHECK-FIXES: struct_type_t GlobalTypedefTestFunction(struct_type_t a_argument1) { struct_type typedef_test_1; -// CHECK-FIXES: {{^}} struct_type_t typedef_test_1; +// CHECK-FIXES: struct_type_t typedef_test_1; return {}; } using my_struct_type = THIS___Structure; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'my_struct_type' -// CHECK-FIXES: {{^}}using my_Struct_Type_t = This_structure;{{$}} +// CHECK-FIXES: using my_Struct_Type_t = This_structure; template<typename t_t> using SomeOtherTemplate = my_other_templated_class <:: FOO_NS ::my_class>; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'SomeOtherTemplate' -// CHECK-FIXES: {{^}}using some_Other_Template_t = CMyOtherTemplatedClass <:: foo_ns ::CMyClass>;{{$}} +// CHECK-FIXES: using some_Other_Template_t = CMyOtherTemplatedClass <:: foo_ns ::CMyClass>; static void static_Function() { // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for function 'static_Function' -// CHECK-FIXES: {{^}}static void staticFunction() {{{$}} +// CHECK-FIXES: static void staticFunction() { ::FOO_NS::InlineNamespace::abstract_class::CLASS_METHOD(); -// CHECK-FIXES: {{^}} ::foo_ns::inline_namespace::AAbstractClass::classMethod();{{$}} +// CHECK-FIXES: ::foo_ns::inline_namespace::AAbstractClass::classMethod(); ::FOO_NS::InlineNamespace::static_Function(); -// CHECK-FIXES: {{^}} ::foo_ns::inline_namespace::staticFunction();{{$}} +// CHECK-FIXES: ::foo_ns::inline_namespace::staticFunction(); using ::FOO_NS::InlineNamespace::CE_function; -// CHECK-FIXES: {{^}} using ::foo_ns::inline_namespace::ce_function;{{$}} +// CHECK-FIXES: using ::foo_ns::inline_namespace::ce_function; unsigned MY_LOCAL_array[] = {1,2,3}; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for local variable 'MY_LOCAL_array' -// CHECK-FIXES: {{^}} unsigned my_local_array[] = {1,2,3};{{$}} +// CHECK-FIXES: unsigned my_local_array[] = {1,2,3}; unsigned const MyConstLocal_array[] = {1,2,3}; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for local constant 'MyConstLocal_array' -// CHECK-FIXES: {{^}} unsigned const kMyConstLocalArray[] = {1,2,3};{{$}} +// CHECK-FIXES: unsigned const kMyConstLocalArray[] = {1,2,3}; static unsigned MY_STATIC_array[] = {1,2,3}; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for static variable 'MY_STATIC_array' -// CHECK-FIXES: {{^}} static unsigned s_myStaticArray[] = {1,2,3};{{$}} +// CHECK-FIXES: static unsigned s_myStaticArray[] = {1,2,3}; static unsigned const MyConstStatic_array[] = {1,2,3}; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for static constant 'MyConstStatic_array' -// CHECK-FIXES: {{^}} static unsigned const MY_CONST_STATIC_ARRAY[] = {1,2,3};{{$}} +// CHECK-FIXES: static unsigned const MY_CONST_STATIC_ARRAY[] = {1,2,3}; char MY_LOCAL_string[] = "123"; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local variable 'MY_LOCAL_string' -// CHECK-FIXES: {{^}} char my_local_string[] = "123";{{$}} +// CHECK-FIXES: char my_local_string[] = "123"; char const MyConstLocal_string[] = "123"; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant 'MyConstLocal_string' -// CHECK-FIXES: {{^}} char const kMyConstLocalString[] = "123";{{$}} +// CHECK-FIXES: char const kMyConstLocalString[] = "123"; static char MY_STATIC_string[] = "123"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for static variable 'MY_STATIC_string' -// CHECK-FIXES: {{^}} static char s_myStaticString[] = "123";{{$}} +// CHECK-FIXES: static char s_myStaticString[] = "123"; static char const MyConstStatic_string[] = "123"; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for static constant 'MyConstStatic_string' -// CHECK-FIXES: {{^}} static char const MY_CONST_STATIC_STRING[] = "123";{{$}} +// CHECK-FIXES: static char const MY_CONST_STATIC_STRING[] = "123"; } #define MY_TEST_Macro(X) X() // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for macro definition 'MY_TEST_Macro' -// CHECK-FIXES: {{^}}#define MY_TEST_MACRO(X) X() +// CHECK-FIXES: #define MY_TEST_MACRO(X) X() void MY_TEST_Macro(function) {} // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global function 'function' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void MY_TEST_MACRO(Function) {} +// CHECK-FIXES: void MY_TEST_MACRO(Function) {} #define MY_CAT_IMPL(l, r) l ## r #define MY_CAT(l, r) MY_CAT_IMPL(l, r) @@ -626,69 +626,69 @@ MY_MACRO3(myglob); template <typename t_t> struct a { // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: invalid case style for struct 'a' -// CHECK-FIXES: {{^}}template <typename t_t> struct A {{{$}} +// CHECK-FIXES: template <typename t_t> struct A { typename t_t::template b<> c; char const MY_ConstMember_string[4] = "123"; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'MY_ConstMember_string' -// CHECK-FIXES: {{^}} char const my_const_member_string[4] = "123";{{$}} +// CHECK-FIXES: char const my_const_member_string[4] = "123"; static char const MyConstClass_string[]; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for class constant 'MyConstClass_string' -// CHECK-FIXES: {{^}} static char const kMyConstClassString[];{{$}} +// CHECK-FIXES: static char const kMyConstClassString[]; }; template<typename t_t> char const a<t_t>::MyConstClass_string[] = "123"; -// CHECK-FIXES: {{^}}char const A<t_t>::kMyConstClassString[] = "123";{{$}} +// CHECK-FIXES: char const A<t_t>::kMyConstClassString[] = "123"; template <template <typename> class A> struct b { A<int> c; }; // CHECK-MESSAGES: :[[@LINE-1]]:47: warning: invalid case style for struct 'b' -// CHECK-FIXES:template <template <typename> class A> struct B { A<int> c; };{{$}} +// CHECK-FIXES: template <template <typename> class A> struct B { A<int> c; }; unsigned MY_GLOBAL_array[] = {1,2,3}; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'MY_GLOBAL_array' -// CHECK-FIXES: {{^}}unsigned g_my_global_array[] = {1,2,3};{{$}} +// CHECK-FIXES: unsigned g_my_global_array[] = {1,2,3}; unsigned const MyConstGlobal_array[] = {1,2,3}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global constant 'MyConstGlobal_array' -// CHECK-FIXES: {{^}}unsigned const MY_CONST_GLOBAL_ARRAY[] = {1,2,3};{{$}} +// CHECK-FIXES: unsigned const MY_CONST_GLOBAL_ARRAY[] = {1,2,3}; int * MyGlobal_Ptr;// -> ok int * my_second_global_Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'my_second_global_Ptr' -// CHECK-FIXES: {{^}}int * MySecondGlobal_Ptr;{{$}} +// CHECK-FIXES: int * MySecondGlobal_Ptr; int * const MyConstantGlobalPointer = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global constant pointer 'MyConstantGlobalPointer' -// CHECK-FIXES: {{^}}int * const MY_CONSTANT_GLOBAL_POINTER_Ptr = nullptr;{{$}} +// CHECK-FIXES: int * const MY_CONSTANT_GLOBAL_POINTER_Ptr = nullptr; void MyPoiterFunction(int * p_normal_pointer, int * const constant_ptr){ // CHECK-MESSAGES: :[[@LINE-1]]:59: warning: invalid case style for constant pointer parameter 'constant_ptr' -// CHECK-FIXES: {{^}}void MyPoiterFunction(int * p_normal_pointer, int * const cp_ConstantPtr){{{$}} +// CHECK-FIXES: void MyPoiterFunction(int * p_normal_pointer, int * const cp_ConstantPtr){ int * l_PointerA; int * const pointer_b = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for local constant pointer 'pointer_b' -// CHECK-FIXES: {{^}} int * const lc_PointerB = nullptr;{{$}} +// CHECK-FIXES: int * const lc_PointerB = nullptr; } using namespace FOO_NS; -// CHECK-FIXES: {{^}}using namespace foo_ns; +// CHECK-FIXES: using namespace foo_ns; using namespace FOO_NS::InlineNamespace; -// CHECK-FIXES: {{^}}using namespace foo_ns::inline_namespace; +// CHECK-FIXES: using namespace foo_ns::inline_namespace; void QualifiedTypeLocTest(THIS___Structure); -// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure);{{$}} +// CHECK-FIXES: void QualifiedTypeLocTest(This_structure); void QualifiedTypeLocTest(THIS___Structure &); -// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure &);{{$}} +// CHECK-FIXES: void QualifiedTypeLocTest(This_structure &); void QualifiedTypeLocTest(THIS___Structure &&); -// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure &&);{{$}} +// CHECK-FIXES: void QualifiedTypeLocTest(This_structure &&); void QualifiedTypeLocTest(const THIS___Structure); -// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const This_structure);{{$}} +// CHECK-FIXES: void QualifiedTypeLocTest(const This_structure); void QualifiedTypeLocTest(const THIS___Structure &); -// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const This_structure &);{{$}} +// CHECK-FIXES: void QualifiedTypeLocTest(const This_structure &); void QualifiedTypeLocTest(volatile THIS___Structure &); -// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(volatile This_structure &);{{$}} +// CHECK-FIXES: void QualifiedTypeLocTest(volatile This_structure &); namespace redecls { // We only want the warning to show up once here for the first decl. @@ -696,15 +696,15 @@ namespace redecls { void badNamedFunction(); void badNamedFunction(); void badNamedFunction(){} -// CHECK-FIXES: {{^}}void BadNamedFunction(); -// CHECK-FIXES-NEXT: {{^}}void BadNamedFunction(); -// CHECK-FIXES-NEXT: {{^}}void BadNamedFunction(){} +// CHECK-FIXES: void BadNamedFunction(); +// CHECK-FIXES-NEXT: void BadNamedFunction(); +// CHECK-FIXES-NEXT: void BadNamedFunction(){} void ReferenceBadNamedFunction() { auto l_Ptr = badNamedFunction; - // CHECK-FIXES: {{^}} auto l_Ptr = BadNamedFunction; + // CHECK-FIXES: auto l_Ptr = BadNamedFunction; l_Ptr(); badNamedFunction(); - // CHECK-FIXES: {{^}} BadNamedFunction(); + // CHECK-FIXES: BadNamedFunction(); } } // namespace redecls @@ -734,7 +734,7 @@ auto GetRes(type_t& Param) -> decltype(Param.res()); struct async_obj { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'async_obj' -// CHECK-FIXES: {{^}}struct Async_obj {{{$}} +// CHECK-FIXES: struct Async_obj { public: never_suspend operator co_await() const noexcept; }; @@ -746,15 +746,15 @@ task ImplicitDeclTest(async_obj &a_object) { // Test scenario when canonical declaration will be a forward declaration struct ForwardDeclStruct; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'ForwardDeclStruct' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct Forward_decl_struct; -// CHECK-FIXES: {{^}}struct Forward_decl_struct { +// CHECK-FIXES: struct Forward_decl_struct; +// CHECK-FIXES: struct Forward_decl_struct { struct ForwardDeclStruct { }; struct forward_declared_as_struct; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for class 'forward_declared_as_struct' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct CForwardDeclaredAsStruct; -// CHECK-FIXES: {{^}}class CForwardDeclaredAsStruct { +// CHECK-FIXES: struct CForwardDeclaredAsStruct; +// CHECK-FIXES: class CForwardDeclaredAsStruct { class forward_declared_as_struct { }; @@ -767,30 +767,30 @@ typedef enum { VALUE1, } ValueType; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: invalid case style for typedef 'ValueType' [readability-identifier-naming] -// CHECK-FIXES: {{^}}} value_type_t; +// CHECK-FIXES: } value_type_t; typedef ValueType (*MyFunPtr)(const ValueType&, Wrap<ValueType>*); // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for typedef 'MyFunPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}typedef value_type_t (*my_fun_ptr_t)(const value_type_t&, Wrap<value_type_t>*); +// CHECK-FIXES: typedef value_type_t (*my_fun_ptr_t)(const value_type_t&, Wrap<value_type_t>*); #define STATIC_MACRO static STATIC_MACRO void someFunc(ValueType a_v1, const ValueType& a_v2) {} -// CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(value_type_t a_v1, const value_type_t& a_v2) {} +// CHECK-FIXES: STATIC_MACRO void someFunc(value_type_t a_v1, const value_type_t& a_v2) {} STATIC_MACRO void someFunc(const ValueType** p_a_v1, ValueType (*p_a_v2)()) {} -// CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(const value_type_t** p_a_v1, value_type_t (*p_a_v2)()) {} +// CHECK-FIXES: STATIC_MACRO void someFunc(const value_type_t** p_a_v1, value_type_t (*p_a_v2)()) {} STATIC_MACRO ValueType someFunc() { return {}; } -// CHECK-FIXES: {{^}}STATIC_MACRO value_type_t someFunc() { return {}; } +// CHECK-FIXES: STATIC_MACRO value_type_t someFunc() { return {}; } STATIC_MACRO void someFunc(MyFunPtr, const MyFunPtr****) {} -// CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(my_fun_ptr_t, const my_fun_ptr_t****) {} +// CHECK-FIXES: STATIC_MACRO void someFunc(my_fun_ptr_t, const my_fun_ptr_t****) {} #undef STATIC_MACRO } struct Some_struct { int SomeMember; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for public member 'SomeMember' [readability-identifier-naming] -// CHECK-FIXES: {{^}} int some_member; +// CHECK-FIXES: int some_member; }; Some_struct g_s1{ .SomeMember = 1 }; -// CHECK-FIXES: {{^}}Some_struct g_s1{ .some_member = 1 }; +// CHECK-FIXES: Some_struct g_s1{ .some_member = 1 }; Some_struct g_s2{.SomeMember=1}; -// CHECK-FIXES: {{^}}Some_struct g_s2{.some_member=1}; +// CHECK-FIXES: Some_struct g_s2{.some_member=1}; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration-fixing.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration-fixing.cpp index 3bd1982..52262eb 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration-fixing.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration-fixing.cpp @@ -13,43 +13,43 @@ void member_pointers() { int S::*p = &S::a, S::*const q = &S::a; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int S::*p = &S::a; - // CHECK-FIXES: {{^ }}int S::*const q = &S::a; + // CHECK-FIXES: int S::*const q = &S::a; int /* :: */ S::*pp2 = &S::a, var1 = 0; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int /* :: */ S::*pp2 = &S::a; - // CHECK-FIXES: {{^ }}int var1 = 0; + // CHECK-FIXES: int var1 = 0; const int S::*r = &S::b, S::*t; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: const int S::*r = &S::b; - // CHECK-FIXES: {{^ }}const int S::*t; + // CHECK-FIXES: const int S::*t; { int S::*mdpa1[2] = {&S::a, &S::a}, var1 = 0; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int S::*mdpa1[2] = {&S::a, &S::a}; - // CHECK-FIXES: {{^ }}int var1 = 0; + // CHECK-FIXES: int var1 = 0; int S ::**mdpa2[2] = {&p, &pp2}, var2 = 0; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int S ::**mdpa2[2] = {&p, &pp2}; - // CHECK-FIXES: {{^ }}int var2 = 0; + // CHECK-FIXES: int var2 = 0; void (S::*mdfp1)() = &S::f, (S::*mdfp2)() = &S::f; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: void (S::*mdfp1)() = &S::f; - // CHECK-FIXES: {{^ }}void (S::*mdfp2)() = &S::f; + // CHECK-FIXES: void (S::*mdfp2)() = &S::f; void (S::*mdfpa1[2])() = {&S::f, &S::f}, (S::*mdfpa2)() = &S::f; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: void (S::*mdfpa1[2])() = {&S::f, &S::f}; - // CHECK-FIXES: {{^ }}void (S::*mdfpa2)() = &S::f; + // CHECK-FIXES: void (S::*mdfpa2)() = &S::f; void (S::* * mdfpa3[2])() = {&mdfpa1[0], &mdfpa1[1]}, (S::*mdfpa4)() = &S::f; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: void (S::* * mdfpa3[2])() = {&mdfpa1[0], &mdfpa1[1]}; - // CHECK-FIXES: {{^ }}void (S::*mdfpa4)() = &S::f; + // CHECK-FIXES: void (S::*mdfpa4)() = &S::f; } class CS { @@ -60,5 +60,5 @@ void member_pointers() { int const CS ::*pp = &CS::a, CS::*const qq = &CS::a; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int const CS ::*pp = &CS::a; - // CHECK-FIXES: {{^ }}int const CS::*const qq = &CS::a; + // CHECK-FIXES: int const CS::*const qq = &CS::a; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration.cpp index 7489d5d..ce3a0da 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration.cpp @@ -8,14 +8,14 @@ void f2() { int i, j, *k, lala = 42; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int i; - // CHECK-FIXES: {{^ }}int j; - // CHECK-FIXES: {{^ }}int *k; - // CHECK-FIXES: {{^ }}int lala = 42; + // CHECK-FIXES: int j; + // CHECK-FIXES: int *k; + // CHECK-FIXES: int lala = 42; int normal, weird = /* comment */ 42; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int normal; - // CHECK-FIXES: {{^ }}int weird = /* comment */ 42; + // CHECK-FIXES: int weird = /* comment */ 42; int /* here is a comment */ v1, // another comment @@ -23,79 +23,79 @@ void f2() { ; // CHECK-MESSAGES: [[@LINE-4]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int /* here is a comment */ v1; - // CHECK-FIXES: {{^ }}int /* here is a comment */ // another comment - // CHECK-FIXES: {{^ }}v2 = 42 // Ok, more comments - // CHECK-FIXES: {{^ }}; + // CHECK-FIXES: int /* here is a comment */ // another comment + // CHECK-FIXES: v2 = 42 // Ok, more comments + // CHECK-FIXES: ; auto int1 = 42, int2 = 0, int3 = 43; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: auto int1 = 42; - // CHECK-FIXES: {{^ }}auto int2 = 0; - // CHECK-FIXES: {{^ }}auto int3 = 43; + // CHECK-FIXES: auto int2 = 0; + // CHECK-FIXES: auto int3 = 43; decltype(auto) ptr1 = &int1, ptr2 = &int1; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: decltype(auto) ptr1 = &int1; - // CHECK-FIXES: {{^ }}decltype(auto) ptr2 = &int1; + // CHECK-FIXES: decltype(auto) ptr2 = &int1; decltype(k) ptr3 = &int1, ptr4 = &int1; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: decltype(k) ptr3 = &int1; - // CHECK-FIXES: {{^ }}decltype(k) ptr4 = &int1; + // CHECK-FIXES: decltype(k) ptr4 = &int1; } void f3() { int i, *pointer1; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int i; - // CHECK-FIXES: {{^ }}int *pointer1; + // CHECK-FIXES: int *pointer1; // int *pointer2 = nullptr, *pointer3 = &i; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int *pointer2 = nullptr; - // CHECK-FIXES: {{^ }}int *pointer3 = &i; + // CHECK-FIXES: int *pointer3 = &i; int *(i_ptr) = nullptr, *((i_ptr2)); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int *(i_ptr) = nullptr; - // CHECK-FIXES: {{^ }}int *((i_ptr2)); + // CHECK-FIXES: int *((i_ptr2)); float(*f_ptr)[42], (((f_value))) = 42; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: float (*f_ptr)[42]; - // CHECK-FIXES: {{^ }}float (((f_value))) = 42; + // CHECK-FIXES: float (((f_value))) = 42; float(((*f_ptr2)))[42], ((*f_ptr3)), f_value2 = 42.f; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: float (((*f_ptr2)))[42]; - // CHECK-FIXES: {{^ }}float ((*f_ptr3)); - // CHECK-FIXES: {{^ }}float f_value2 = 42.f; + // CHECK-FIXES: float ((*f_ptr3)); + // CHECK-FIXES: float f_value2 = 42.f; float(((*f_ptr4)))[42], *f_ptr5, ((f_value3)); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: float (((*f_ptr4)))[42]; - // CHECK-FIXES: {{^ }}float *f_ptr5; - // CHECK-FIXES: {{^ }}float ((f_value3)); + // CHECK-FIXES: float *f_ptr5; + // CHECK-FIXES: float ((f_value3)); void(((*f2))(int)), (*g2)(int, float); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: void (((*f2))(int)); - // CHECK-FIXES: {{^ }}void (*g2)(int, float); + // CHECK-FIXES: void (*g2)(int, float); float(*(*(*f_ptr6)))[42], (*f_ptr7); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: float (*(*(*f_ptr6)))[42]; - // CHECK-FIXES: {{^ }}float (*f_ptr7); + // CHECK-FIXES: float (*f_ptr7); } void f4() { double d = 42. /* foo */, z = 43., /* hi */ y, c /* */ /* */, l = 2.; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: double d = 42. /* foo */; - // CHECK-FIXES: {{^ }}double z = 43.; - // CHECK-FIXES: {{^ }}double /* hi */ y; - // CHECK-FIXES: {{^ }}double c /* */ /* */; - // CHECK-FIXES: {{^ }}double l = 2.; + // CHECK-FIXES: double z = 43.; + // CHECK-FIXES: double /* hi */ y; + // CHECK-FIXES: double c /* */ /* */; + // CHECK-FIXES: double l = 2.; } struct SomeClass { @@ -123,35 +123,35 @@ void f5() { SomeClass v1, v2(42), v3{42}, v4(42.5); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: SomeClass v1; - // CHECK-FIXES: {{^ }}SomeClass v2(42); - // CHECK-FIXES: {{^ }}SomeClass v3{42}; - // CHECK-FIXES: {{^ }}SomeClass v4(42.5); + // CHECK-FIXES: SomeClass v2(42); + // CHECK-FIXES: SomeClass v3{42}; + // CHECK-FIXES: SomeClass v4(42.5); SomeClass v5 = 42, *p1 = nullptr; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: SomeClass v5 = 42; - // CHECK-FIXES: {{^ }}SomeClass *p1 = nullptr; + // CHECK-FIXES: SomeClass *p1 = nullptr; Point P1(0., 2.), P2{2., 0.}; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: Point P1(0., 2.); - // CHECK-FIXES: {{^ }}Point P2{2., 0.}; + // CHECK-FIXES: Point P2{2., 0.}; Rectangle R1({0., 0.}, {1., -2.}), R2{{0., 1.}, {1., 0.}}, R3(P1, P2), R4{P1, P2}; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: Rectangle R1({0., 0.}, {1., -2.}); - // CHECK-FIXES: {{^ }}Rectangle R2{{[{][{]}}0., 1.}, {1., 0.{{[}][}]}}; - // CHECK-FIXES: {{^ }}Rectangle R3(P1, P2); - // CHECK-FIXES: {{^ }}Rectangle R4{P1, P2}; + // CHECK-FIXES: Rectangle R2{{[{][{]}}0., 1.}, {1., 0.{{[}][}]}}; + // CHECK-FIXES: Rectangle R3(P1, P2); + // CHECK-FIXES: Rectangle R4{P1, P2}; } void f6() { int array1[] = {1, 2, 3, 4}, array2[] = {1, 2, 3}, value1, value2 = 42; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int array1[] = {1, 2, 3, 4}; - // CHECK-FIXES: {{^ }}int array2[] = {1, 2, 3}; - // CHECK-FIXES: {{^ }}int value1; - // CHECK-FIXES: {{^ }}int value2 = 42; + // CHECK-FIXES: int array2[] = {1, 2, 3}; + // CHECK-FIXES: int value1; + // CHECK-FIXES: int value2 = 42; } template <typename T> @@ -164,25 +164,25 @@ void f7() { TemplatedType<int> TT1(42), TT2{42}, TT3; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: TemplatedType<int> TT1(42); - // CHECK-FIXES: {{^ }}TemplatedType<int> TT2{42}; - // CHECK-FIXES: {{^ }}TemplatedType<int> TT3; + // CHECK-FIXES: TemplatedType<int> TT2{42}; + // CHECK-FIXES: TemplatedType<int> TT3; // TemplatedType<int *> *TT4(nullptr), TT5, **TT6 = nullptr, *const *const TT7{nullptr}; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: TemplatedType<int *> *TT4(nullptr); - // CHECK-FIXES: {{^ }}TemplatedType<int *> TT5; - // CHECK-FIXES: {{^ }}TemplatedType<int *> **TT6 = nullptr; - // CHECK-FIXES: {{^ }}TemplatedType<int *> *const *const TT7{nullptr}; + // CHECK-FIXES: TemplatedType<int *> TT5; + // CHECK-FIXES: TemplatedType<int *> **TT6 = nullptr; + // CHECK-FIXES: TemplatedType<int *> *const *const TT7{nullptr}; TemplatedType<int &> **TT8(nullptr), *TT9; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: TemplatedType<int &> **TT8(nullptr); - // CHECK-FIXES: {{^ }}TemplatedType<int &> *TT9; + // CHECK-FIXES: TemplatedType<int &> *TT9; TemplatedType<int *> TT10{nullptr}, *TT11(nullptr); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: TemplatedType<int *> TT10{nullptr}; - // CHECK-FIXES: {{^ }}TemplatedType<int *> *TT11(nullptr); + // CHECK-FIXES: TemplatedType<int *> *TT11(nullptr); } void forbidden_transformations() { @@ -199,7 +199,7 @@ void macros() { int *p1 = NULL, *p2 = NULL; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int *p1 = NULL; - // CHECK-FIXES: {{^ }}int *p2 = NULL; + // CHECK-FIXES: int *p2 = NULL; // Macros are involved, so there will be no transformation MY_NICE_TYPE p3, v1, v2; @@ -253,25 +253,25 @@ void complex_typedefs() { IntPtr intptr1, intptr2 = nullptr, intptr3; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: IntPtr intptr1; - // CHECK-FIXES: {{^ }}IntPtr intptr2 = nullptr; - // CHECK-FIXES: {{^ }}IntPtr intptr3; + // CHECK-FIXES: IntPtr intptr2 = nullptr; + // CHECK-FIXES: IntPtr intptr3; IntPtr *DoublePtr1 = nullptr, **TriplePtr, SinglePtr = nullptr; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: IntPtr *DoublePtr1 = nullptr; - // CHECK-FIXES: {{^ }}IntPtr **TriplePtr; - // CHECK-FIXES: {{^ }}IntPtr SinglePtr = nullptr; + // CHECK-FIXES: IntPtr **TriplePtr; + // CHECK-FIXES: IntPtr SinglePtr = nullptr; IntPtr intptr_array1[2], intptr_array2[4] = {nullptr, nullptr, nullptr, nullptr}; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: IntPtr intptr_array1[2]; - // CHECK-FIXES: {{^ }}IntPtr intptr_array2[4] = {nullptr, nullptr, nullptr, nullptr}; + // CHECK-FIXES: IntPtr intptr_array2[4] = {nullptr, nullptr, nullptr, nullptr}; ArrayType arraytype1, arraytype2 = {1}, arraytype3; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: ArrayType arraytype1; - // CHECK-FIXES: {{^ }}ArrayType arraytype2 = {1}; - // CHECK-FIXES: {{^ }}ArrayType arraytype3; + // CHECK-FIXES: ArrayType arraytype2 = {1}; + // CHECK-FIXES: ArrayType arraytype3; // Don't touch function declarations. FunType funtype1, funtype2, functype3; @@ -280,29 +280,29 @@ void complex_typedefs() { int localFor1 = 1, localFor2 = 2; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int localFor1 = 1; - // CHECK-FIXES: {{^ }}int localFor2 = 2; + // CHECK-FIXES: int localFor2 = 2; } StructOne s1, s2(23), s3, s4(3), *sptr = new StructOne(2); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: StructOne s1; - // CHECK-FIXES: {{^ }}StructOne s2(23); - // CHECK-FIXES: {{^ }}StructOne s3; - // CHECK-FIXES: {{^ }}StructOne s4(3); - // CHECK-FIXES: {{^ }}StructOne *sptr = new StructOne(2); + // CHECK-FIXES: StructOne s2(23); + // CHECK-FIXES: StructOne s3; + // CHECK-FIXES: StructOne s4(3); + // CHECK-FIXES: StructOne *sptr = new StructOne(2); struct StructOne cs1, cs2(42); // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: struct StructOne cs1; - // CHECK-FIXES: {{^ }}struct StructOne cs2(42); + // CHECK-FIXES: struct StructOne cs2(42); int *ptrArray[3], dummy, **ptrArray2[5], twoDim[2][3], *twoDimPtr[2][3]; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int *ptrArray[3]; - // CHECK-FIXES: {{^ }}int dummy; - // CHECK-FIXES: {{^ }}int **ptrArray2[5]; - // CHECK-FIXES: {{^ }}int twoDim[2][3]; - // CHECK-FIXES: {{^ }}int *twoDimPtr[2][3]; + // CHECK-FIXES: int dummy; + // CHECK-FIXES: int **ptrArray2[5]; + // CHECK-FIXES: int twoDim[2][3]; + // CHECK-FIXES: int *twoDimPtr[2][3]; { void f1(int), g1(int, float); @@ -314,12 +314,12 @@ void complex_typedefs() { void (*f2)(int), (*g2)(int, float) = gg; // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: void (*f2)(int); - // CHECK-FIXES: {{^ }}void (*g2)(int, float) = gg; + // CHECK-FIXES: void (*g2)(int, float) = gg; void /*(*/ (/*(*/ *f3)(int), (*g3)(int, float); // CHECK-MESSAGES: [[@LINE-1]]:5: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: void /*(*/ (/*(*/ *f3)(int); - // CHECK-FIXES: {{^ }}void /*(*/ (*g3)(int, float); + // CHECK-FIXES: void /*(*/ (*g3)(int, float); } // clang-format off @@ -333,26 +333,26 @@ void complex_typedefs() { }, bb = 4; // CHECK-MESSAGES: [[@LINE-7]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int intfunction = returner(); - // CHECK-FIXES: {{^ }}int intarray[] = - // CHECK-FIXES: {{^ }}{ - // CHECK-FIXES: {{^ }}1, - // CHECK-FIXES: {{^ }}2, - // CHECK-FIXES: {{^ }}3, - // CHECK-FIXES: {{^ }}4 - // CHECK-FIXES: {{^ }}}; - // CHECK-FIXES: {{^ }}int bb = 4; + // CHECK-FIXES: int intarray[] = + // CHECK-FIXES: { + // CHECK-FIXES: 1, + // CHECK-FIXES: 2, + // CHECK-FIXES: 3, + // CHECK-FIXES: 4 + // CHECK-FIXES: }; + // CHECK-FIXES: int bb = 4; // clang-format on TemT *T1 = &TT1, *T2 = &TT2; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: TemT *T1 = &TT1; - // CHECK-FIXES: {{^ }}TemT *T2 = &TT2; + // CHECK-FIXES: TemT *T2 = &TT2; const PointerType *PT1 = T1->getAs<PointerType>(), *PT2 = T2->getAs<PointerType>(); // CHECK-MESSAGES: [[@LINE-2]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: const PointerType *PT1 = T1->getAs<PointerType>(); - // CHECK-FIXES: {{^ }}const PointerType *PT2 = T2->getAs<PointerType>(); + // CHECK-FIXES: const PointerType *PT2 = T2->getAs<PointerType>(); const int *p1 = nullptr; const int *p2 = nullptr; @@ -360,7 +360,7 @@ void complex_typedefs() { const int *&pref1 = p1, *&pref2 = p2; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: const int *&pref1 = p1; - // CHECK-FIXES: {{^ }}const int *&pref2 = p2; + // CHECK-FIXES: const int *&pref2 = p2; // clang-format off const char *literal1 = "clang" "test"\ @@ -368,9 +368,9 @@ void complex_typedefs() { *literal2 = "empty", literal3[] = "three"; // CHECK-MESSAGES: [[@LINE-3]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: const char *literal1 = "clang" "test"\ - // CHECK-FIXES: {{^ }}"one"; - // CHECK-FIXES: {{^ }}const char *literal2 = "empty"; - // CHECK-FIXES: {{^ }}const char literal3[] = "three"; + // CHECK-FIXES: "one"; + // CHECK-FIXES: const char *literal2 = "empty"; + // CHECK-FIXES: const char literal3[] = "three"; // clang-format on } @@ -378,7 +378,7 @@ void g() try { int i, j; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: int i; - // CHECK-FIXES: {{^ }}int j; + // CHECK-FIXES: int j; } catch (...) { } @@ -393,7 +393,7 @@ void memberPointers() { MemPtr aaa = &S::a, bbb = &S::b; // CHECK-MESSAGES: [[@LINE-1]]:3: warning: multiple declarations in a single statement reduces readability // CHECK-FIXES: MemPtr aaa = &S::a; - // CHECK-FIXES: {{^ }}MemPtr bbb = &S::b; + // CHECK-FIXES: MemPtr bbb = &S::b; } typedef int *tptr, tbt; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/make-member-function-const.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/make-member-function-const.cpp index d454ad2..72a8e36 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/make-member-function-const.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/make-member-function-const.cpp @@ -24,107 +24,107 @@ struct A { int read_field() { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_field' can be made const - // CHECK-FIXES: {{^}} int read_field() const { + // CHECK-FIXES: int read_field() const { return M; } int read_struct_field() { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_struct_field' can be made const - // CHECK-FIXES: {{^}} int read_struct_field() const { + // CHECK-FIXES: int read_struct_field() const { return Struct.M; } int read_const_field() { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_const_field' can be made const - // CHECK-FIXES: {{^}} int read_const_field() const { + // CHECK-FIXES: int read_const_field() const { return ConstM; } int read_fields_in_parentheses() { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_fields_in_parentheses' can be made const - // CHECK-FIXES: {{^}} int read_fields_in_parentheses() const { + // CHECK-FIXES: int read_fields_in_parentheses() const { return (this)->M + (((((Struct.M))))) + ((this->ConstM)); } void call_const_member() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'call_const_member' can be made const - // CHECK-FIXES: {{^}} void call_const_member() const { + // CHECK-FIXES: void call_const_member() const { already_const(); } void call_const_member_on_public_field() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'call_const_member_on_public_field' can be made const - // CHECK-FIXES: {{^}} void call_const_member_on_public_field() const { + // CHECK-FIXES: void call_const_member_on_public_field() const { S.const_method(); } void call_const_member_on_public_field_ref() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'call_const_member_on_public_field_ref' can be made const - // CHECK-FIXES: {{^}} void call_const_member_on_public_field_ref() const { + // CHECK-FIXES: void call_const_member_on_public_field_ref() const { Sref.const_method(); } const Str &return_public_field_ref() { // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: method 'return_public_field_ref' can be made const - // CHECK-FIXES: {{^}} const Str &return_public_field_ref() const { + // CHECK-FIXES: const Str &return_public_field_ref() const { return S; } const A *return_this_const() { // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: method 'return_this_const' can be made const - // CHECK-FIXES: {{^}} const A *return_this_const() const { + // CHECK-FIXES: const A *return_this_const() const { return this; } const A &return_this_const_ref() { // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: method 'return_this_const_ref' can be made const - // CHECK-FIXES: {{^}} const A &return_this_const_ref() const { + // CHECK-FIXES: const A &return_this_const_ref() const { return *this; } void const_use() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'const_use' can be made const - // CHECK-FIXES: {{^}} void const_use() const { + // CHECK-FIXES: void const_use() const { free_const_use(this); } void const_use_ref() { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'const_use_ref' can be made const - // CHECK-FIXES: {{^}} void const_use_ref() const { + // CHECK-FIXES: void const_use_ref() const { free_const_use(*this); } auto trailingReturn() -> int { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'trailingReturn' can be made const - // CHECK-FIXES: {{^}} auto trailingReturn() const -> int { + // CHECK-FIXES: auto trailingReturn() const -> int { return M; } int volatileFunction() volatile { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'volatileFunction' can be made const - // CHECK-FIXES: {{^}} int volatileFunction() const volatile { + // CHECK-FIXES: int volatileFunction() const volatile { return M; } int restrictFunction() __restrict { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'restrictFunction' can be made const - // CHECK-FIXES: {{^}} int restrictFunction() const __restrict { + // CHECK-FIXES: int restrictFunction() const __restrict { return M; } int refFunction() & { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'refFunction' can be made const - // CHECK-FIXES: {{^}} int refFunction() const & { + // CHECK-FIXES: int refFunction() const & { return M; } void out_of_line_call_const(); - // CHECK-FIXES: {{^}} void out_of_line_call_const() const; + // CHECK-FIXES: void out_of_line_call_const() const; }; void A::out_of_line_call_const() { // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: method 'out_of_line_call_const' can be made const - // CHECK-FIXES: {{^}}void A::out_of_line_call_const() const { + // CHECK-FIXES: void A::out_of_line_call_const() const { already_const(); } } // namespace Diagnose diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.c b/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.c index e254215..c5ddf03 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.c +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.c @@ -5,7 +5,7 @@ static int f(); int f(p) int *p; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: pointer parameter 'p' can be pointer to const [readability-non-const-parameter] -// CHECK-FIXES: {{^}} const int *p;{{$}} +// CHECK-FIXES: const int *p; { return *p; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.cpp index 1f89e0b..a118c32 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.cpp @@ -14,7 +14,7 @@ unsigned my_strlen(const char *buf); // CHECK-MESSAGES: :[[@LINE+1]]:29: warning: pointer parameter 'last' can be pointer to const [readability-non-const-parameter] void warn1(int *first, int *last) { - // CHECK-FIXES: {{^}}void warn1(int *first, const int *last) {{{$}} + // CHECK-FIXES: void warn1(int *first, const int *last) { *first = 0; if (first < last) { } // <- last can be const @@ -28,14 +28,14 @@ void warn2(char *p) { // CHECK-MESSAGES: :[[@LINE+1]]:19: warning: pointer parameter 'p' can be void assign1(int *p) { - // CHECK-FIXES: {{^}}void assign1(const int *p) {{{$}} + // CHECK-FIXES: void assign1(const int *p) { const int *q; q = p; } // CHECK-MESSAGES: :[[@LINE+1]]:19: warning: pointer parameter 'p' can be void assign2(int *p) { - // CHECK-FIXES: {{^}}void assign2(const int *p) {{{$}} + // CHECK-FIXES: void assign2(const int *p) { const int *q; q = p + 1; } @@ -82,13 +82,13 @@ void assign10(int *buf) { // CHECK-MESSAGES: :[[@LINE+1]]:17: warning: pointer parameter 'p' can be void init1(int *p) { - // CHECK-FIXES: {{^}}void init1(const int *p) {{{$}} + // CHECK-FIXES: void init1(const int *p) { const int *q = p; } // CHECK-MESSAGES: :[[@LINE+1]]:17: warning: pointer parameter 'p' can be void init2(int *p) { - // CHECK-FIXES: {{^}}void init2(const int *p) {{{$}} + // CHECK-FIXES: void init2(const int *p) { const int *q = p + 1; } @@ -115,25 +115,25 @@ void init7(int *p, int x) { // CHECK-MESSAGES: :[[@LINE+1]]:18: warning: pointer parameter 'p' can be int return1(int *p) { - // CHECK-FIXES: {{^}}int return1(const int *p) {{{$}} + // CHECK-FIXES: int return1(const int *p) { return *p; } // CHECK-MESSAGES: :[[@LINE+1]]:25: warning: pointer parameter 'p' can be const int *return2(int *p) { - // CHECK-FIXES: {{^}}const int *return2(const int *p) {{{$}} + // CHECK-FIXES: const int *return2(const int *p) { return p; } // CHECK-MESSAGES: :[[@LINE+1]]:25: warning: pointer parameter 'p' can be const int *return3(int *p) { - // CHECK-FIXES: {{^}}const int *return3(const int *p) {{{$}} + // CHECK-FIXES: const int *return3(const int *p) { return p + 1; } // CHECK-MESSAGES: :[[@LINE+1]]:27: warning: pointer parameter 'p' can be const char *return4(char *p) { - // CHECK-FIXES: {{^}}const char *return4(const char *p) {{{$}} + // CHECK-FIXES: const char *return4(const char *p) { return p ? p : ""; } @@ -231,13 +231,13 @@ struct XYConst { }; // CHECK-MESSAGES: :[[@LINE+1]]:30: warning: pointer parameter 'x' can be pointer to const void recordInitListDiag(int *x) { - // CHECK-FIXES: {{^}}void recordInitListDiag(const int *x) {{{$}} + // CHECK-FIXES: void recordInitListDiag(const int *x) { XYConst xy = {x}; } typedef XYConst XYConstAlias; // CHECK-MESSAGES: :[[@LINE+1]]:35: warning: pointer parameter 'x' can be pointer to const void recordInitListAliasDiag(int *x) { - // CHECK-FIXES: {{^}}void recordInitListAliasDiag(const int *x) {{{$}} + // CHECK-FIXES: void recordInitListAliasDiag(const int *x) { XYConstAlias xy = {x}; } @@ -253,7 +253,7 @@ class C2 { public: // CHECK-MESSAGES: :[[@LINE+1]]:11: warning: pointer parameter 'p' can be C2(int *p) : p(p) {} - // CHECK-FIXES: {{^}} C2(const int *p) : p(p) {}{{$}} + // CHECK-FIXES: C2(const int *p) : p(p) {} private: const int *p; @@ -272,7 +272,7 @@ class Warn { public: // CHECK-MESSAGES: :[[@LINE+1]]:21: warning: pointer parameter 'p' can be void doStuff(int *p) { - // CHECK-FIXES: {{^}} void doStuff(const int *p) {{{$}} + // CHECK-FIXES: void doStuff(const int *p) { x = *p; } @@ -297,14 +297,14 @@ public: }; extern char foo(char *s); // 1 -// CHECK-FIXES: {{^}}extern char foo(const char *s); // 1{{$}} +// CHECK-FIXES: extern char foo(const char *s); // 1 // CHECK-MESSAGES: :[[@LINE+1]]:16: warning: pointer parameter 's' can be char foo(char *s) { - // CHECK-FIXES: {{^}}char foo(const char *s) {{{$}} + // CHECK-FIXES: char foo(const char *s) { return *s; } char foo(char *s); // 2 -// CHECK-FIXES: {{^}}char foo(const char *s); // 2{{$}} +// CHECK-FIXES: char foo(const char *s); // 2 void lvalueReference(int *p) { // CHECK-MESSAGES-NOT: warning: pointer parameter 'p' can be @@ -313,7 +313,7 @@ void lvalueReference(int *p) { // CHECK-MESSAGES: :[[@LINE+1]]:32: warning: pointer parameter 'p' can be void constLValueReference(int *p) { - // CHECK-FIXES: {{^}}void constLValueReference(const int *p) {{{$}} + // CHECK-FIXES: void constLValueReference(const int *p) { const int &x = *p; } @@ -326,7 +326,7 @@ void lambdaLVRef(int *p) { // CHECK-MESSAGES: :[[@LINE+1]]:28: warning: pointer parameter 'p' can be void lambdaConstLVRef(int *p) { - // CHECK-FIXES: {{^}}void lambdaConstLVRef(const int *p) {{{$}} + // CHECK-FIXES: void lambdaConstLVRef(const int *p) { auto foo = [&]() { const int &x = *p; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-alternative.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-alternative.cpp index 5f70844..0cdf6a7 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-alternative.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-alternative.cpp @@ -7,47 +7,47 @@ void testAllTokensToAlternative(int a, int b) { value = a||b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '||' is a traditional token spelling, consider using an alternative token 'or' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a or b;{{$}} + // CHECK-FIXES: value = a or b; value = a&&b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '&&' is a traditional token spelling, consider using an alternative token 'and' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a and b;{{$}} + // CHECK-FIXES: value = a and b; value = a | b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '|' is a traditional token spelling, consider using an alternative token 'bitor' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a bitor b;{{$}} + // CHECK-FIXES: value = a bitor b; value = a & b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '&' is a traditional token spelling, consider using an alternative token 'bitand' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a bitand b;{{$}} + // CHECK-FIXES: value = a bitand b; value = !a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '!' is a traditional token spelling, consider using an alternative token 'not' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = not a;{{$}} + // CHECK-FIXES: value = not a; value = a^b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '^' is a traditional token spelling, consider using an alternative token 'xor' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a xor b;{{$}} + // CHECK-FIXES: value = a xor b; value = ~b; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '~' is a traditional token spelling, consider using an alternative token 'compl' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = compl b;{{$}} + // CHECK-FIXES: value = compl b; value &= b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '&=' is a traditional token spelling, consider using an alternative token 'and_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value and_eq b;{{$}} + // CHECK-FIXES: value and_eq b; value |= b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '|=' is a traditional token spelling, consider using an alternative token 'or_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value or_eq b;{{$}} + // CHECK-FIXES: value or_eq b; value = a != b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '!=' is a traditional token spelling, consider using an alternative token 'not_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a not_eq b;{{$}} + // CHECK-FIXES: value = a not_eq b; value ^= a; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '^=' is a traditional token spelling, consider using an alternative token 'xor_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value xor_eq a;{{$}} + // CHECK-FIXES: value xor_eq a; } struct Class { @@ -70,47 +70,47 @@ void testAllTokensToAlternative(Class a, Class b) { value = a||b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '||' is a traditional token spelling, consider using an alternative token 'or' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a or b;{{$}} + // CHECK-FIXES: value = a or b; value = a&&b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '&&' is a traditional token spelling, consider using an alternative token 'and' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a and b;{{$}} + // CHECK-FIXES: value = a and b; clval = a | b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '|' is a traditional token spelling, consider using an alternative token 'bitor' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a bitor b;{{$}} + // CHECK-FIXES: clval = a bitor b; clval = a & b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '&' is a traditional token spelling, consider using an alternative token 'bitand' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a bitand b;{{$}} + // CHECK-FIXES: clval = a bitand b; value = !a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '!' is a traditional token spelling, consider using an alternative token 'not' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = not a;{{$}} + // CHECK-FIXES: value = not a; clval = a^b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '^' is a traditional token spelling, consider using an alternative token 'xor' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a xor b;{{$}} + // CHECK-FIXES: clval = a xor b; clval = ~b; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '~' is a traditional token spelling, consider using an alternative token 'compl' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = compl b;{{$}} + // CHECK-FIXES: clval = compl b; clval &= b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '&=' is a traditional token spelling, consider using an alternative token 'and_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval and_eq b;{{$}} + // CHECK-FIXES: clval and_eq b; clval |= b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '|=' is a traditional token spelling, consider using an alternative token 'or_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval or_eq b;{{$}} + // CHECK-FIXES: clval or_eq b; value = a != b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '!=' is a traditional token spelling, consider using an alternative token 'not_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a not_eq b;{{$}} + // CHECK-FIXES: value = a not_eq b; clval ^= a; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '^=' is a traditional token spelling, consider using an alternative token 'xor_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval xor_eq a;{{$}} + // CHECK-FIXES: clval xor_eq a; } struct ClassO {}; @@ -133,45 +133,45 @@ void testAllTokensToAlternative(ClassO a, ClassO b) { value = a||b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '||' is a traditional token spelling, consider using an alternative token 'or' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a or b;{{$}} + // CHECK-FIXES: value = a or b; value = a&&b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '&&' is a traditional token spelling, consider using an alternative token 'and' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a and b;{{$}} + // CHECK-FIXES: value = a and b; clval = a | b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '|' is a traditional token spelling, consider using an alternative token 'bitor' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a bitor b;{{$}} + // CHECK-FIXES: clval = a bitor b; clval = a & b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '&' is a traditional token spelling, consider using an alternative token 'bitand' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a bitand b;{{$}} + // CHECK-FIXES: clval = a bitand b; value = !a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '!' is a traditional token spelling, consider using an alternative token 'not' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = not a;{{$}} + // CHECK-FIXES: value = not a; clval = a^b; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: '^' is a traditional token spelling, consider using an alternative token 'xor' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a xor b;{{$}} + // CHECK-FIXES: clval = a xor b; clval = ~b; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: '~' is a traditional token spelling, consider using an alternative token 'compl' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = compl b;{{$}} + // CHECK-FIXES: clval = compl b; clval &= b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '&=' is a traditional token spelling, consider using an alternative token 'and_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval and_eq b;{{$}} + // CHECK-FIXES: clval and_eq b; clval |= b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '|=' is a traditional token spelling, consider using an alternative token 'or_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval or_eq b;{{$}} + // CHECK-FIXES: clval or_eq b; value = a != b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: '!=' is a traditional token spelling, consider using an alternative token 'not_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a not_eq b;{{$}} + // CHECK-FIXES: value = a not_eq b; clval ^= a; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: '^=' is a traditional token spelling, consider using an alternative token 'xor_eq' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval xor_eq a;{{$}} + // CHECK-FIXES: clval xor_eq a; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-traditional.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-traditional.cpp index 5c421a0..d5f056e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-traditional.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/operators-representation-to-traditional.cpp @@ -7,47 +7,47 @@ void testAllTokensToAlternative(int a, int b) { value = a or b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'or' is an alternative token spelling, consider using a traditional token '||' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a || b;{{$}} + // CHECK-FIXES: value = a || b; value = a and b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'and' is an alternative token spelling, consider using a traditional token '&&' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a && b;{{$}} + // CHECK-FIXES: value = a && b; value = a bitor b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitor' is an alternative token spelling, consider using a traditional token '|' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a | b;{{$}} + // CHECK-FIXES: value = a | b; value = a bitand b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitand' is an alternative token spelling, consider using a traditional token '&' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a & b;{{$}} + // CHECK-FIXES: value = a & b; value = not a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'not' is an alternative token spelling, consider using a traditional token '!' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = ! a;{{$}} + // CHECK-FIXES: value = ! a; value = a xor b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'xor' is an alternative token spelling, consider using a traditional token '^' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a ^ b;{{$}} + // CHECK-FIXES: value = a ^ b; value = compl b; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'compl' is an alternative token spelling, consider using a traditional token '~' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = ~ b;{{$}} + // CHECK-FIXES: value = ~ b; value and_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'and_eq' is an alternative token spelling, consider using a traditional token '&=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value &= b;{{$}} + // CHECK-FIXES: value &= b; value or_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'or_eq' is an alternative token spelling, consider using a traditional token '|=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value |= b;{{$}} + // CHECK-FIXES: value |= b; value = a not_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'not_eq' is an alternative token spelling, consider using a traditional token '!=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a != b;{{$}} + // CHECK-FIXES: value = a != b; value xor_eq a; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value ^= a;{{$}} + // CHECK-FIXES: value ^= a; } struct Class { @@ -70,47 +70,47 @@ void testAllTokensToAlternative(Class a, Class b) { value = a or b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'or' is an alternative token spelling, consider using a traditional token '||' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a || b;{{$}} + // CHECK-FIXES: value = a || b; value = a and b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'and' is an alternative token spelling, consider using a traditional token '&&' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a && b;{{$}} + // CHECK-FIXES: value = a && b; clval = a bitor b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitor' is an alternative token spelling, consider using a traditional token '|' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a | b;{{$}} + // CHECK-FIXES: clval = a | b; clval = a bitand b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitand' is an alternative token spelling, consider using a traditional token '&' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a & b;{{$}} + // CHECK-FIXES: clval = a & b; value = not a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'not' is an alternative token spelling, consider using a traditional token '!' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = ! a;{{$}} + // CHECK-FIXES: value = ! a; clval = a xor b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'xor' is an alternative token spelling, consider using a traditional token '^' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a ^ b;{{$}} + // CHECK-FIXES: clval = a ^ b; clval = compl b; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'compl' is an alternative token spelling, consider using a traditional token '~' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = ~ b;{{$}} + // CHECK-FIXES: clval = ~ b; clval and_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'and_eq' is an alternative token spelling, consider using a traditional token '&=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval &= b;{{$}} + // CHECK-FIXES: clval &= b; clval or_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'or_eq' is an alternative token spelling, consider using a traditional token '|=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval |= b;{{$}} + // CHECK-FIXES: clval |= b; value = a not_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'not_eq' is an alternative token spelling, consider using a traditional token '!=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a != b;{{$}} + // CHECK-FIXES: value = a != b; clval xor_eq a; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval ^= a;{{$}} + // CHECK-FIXES: clval ^= a; } struct ClassO {}; @@ -133,45 +133,45 @@ void testAllTokensToAlternative(ClassO a, ClassO b) { value = a or b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'or' is an alternative token spelling, consider using a traditional token '||' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a || b;{{$}} + // CHECK-FIXES: value = a || b; value = a and b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'and' is an alternative token spelling, consider using a traditional token '&&' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a && b;{{$}} + // CHECK-FIXES: value = a && b; clval = a bitor b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitor' is an alternative token spelling, consider using a traditional token '|' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a | b;{{$}} + // CHECK-FIXES: clval = a | b; clval = a bitand b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'bitand' is an alternative token spelling, consider using a traditional token '&' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a & b;{{$}} + // CHECK-FIXES: clval = a & b; value = not a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'not' is an alternative token spelling, consider using a traditional token '!' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = ! a;{{$}} + // CHECK-FIXES: value = ! a; clval = a xor b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'xor' is an alternative token spelling, consider using a traditional token '^' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = a ^ b;{{$}} + // CHECK-FIXES: clval = a ^ b; clval = compl b; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'compl' is an alternative token spelling, consider using a traditional token '~' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval = ~ b;{{$}} + // CHECK-FIXES: clval = ~ b; clval and_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'and_eq' is an alternative token spelling, consider using a traditional token '&=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval &= b;{{$}} + // CHECK-FIXES: clval &= b; clval or_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'or_eq' is an alternative token spelling, consider using a traditional token '|=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval |= b;{{$}} + // CHECK-FIXES: clval |= b; value = a not_eq b; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'not_eq' is an alternative token spelling, consider using a traditional token '!=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}value = a != b;{{$}} + // CHECK-FIXES: value = a != b; clval xor_eq a; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: 'xor_eq' is an alternative token spelling, consider using a traditional token '^=' for consistency [readability-operators-representation] - // CHECK-FIXES: {{^ }}clval ^= a;{{$}} + // CHECK-FIXES: clval ^= a; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto-cxx20.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto-cxx20.cpp index 9982d8f..fea0034 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto-cxx20.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto-cxx20.cpp @@ -18,32 +18,32 @@ const std::vector<int> *getCVec(); void foo() { if (auto X = getVec(); X->size() > 0) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: 'auto X' can be declared as 'auto *X' - // CHECK-FIXES: {{^}} if (auto *X = getVec(); X->size() > 0) { + // CHECK-FIXES: if (auto *X = getVec(); X->size() > 0) { } switch (auto X = getVec(); X->size()) { // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'auto X' can be declared as 'auto *X' - // CHECK-FIXES: {{^}} switch (auto *X = getVec(); X->size()) { + // CHECK-FIXES: switch (auto *X = getVec(); X->size()) { default: break; } for (auto X = getVec(); auto Xi : *X) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto X' can be declared as 'auto *X' - // CHECK-FIXES: {{^}} for (auto *X = getVec(); auto Xi : *X) { + // CHECK-FIXES: for (auto *X = getVec(); auto Xi : *X) { } } void bar() { if (auto X = getCVec(); X->size() > 0) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: 'auto X' can be declared as 'const auto *X' - // CHECK-FIXES: {{^}} if (const auto *X = getCVec(); X->size() > 0) { + // CHECK-FIXES: if (const auto *X = getCVec(); X->size() > 0) { } switch (auto X = getCVec(); X->size()) { // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 'auto X' can be declared as 'const auto *X' - // CHECK-FIXES: {{^}} switch (const auto *X = getCVec(); X->size()) { + // CHECK-FIXES: switch (const auto *X = getCVec(); X->size()) { default: break; } for (auto X = getCVec(); auto Xi : *X) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto X' can be declared as 'const auto *X' - // CHECK-FIXES: {{^}} for (const auto *X = getCVec(); auto Xi : *X) { + // CHECK-FIXES: for (const auto *X = getCVec(); auto Xi : *X) { } } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto.cpp index 83b7b1d..ffcf84e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/qualified-auto.cpp @@ -24,27 +24,27 @@ CMyRef getCRef(); void foo() { auto TdNakedPtr = getPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto TdNakedPtr' can be declared as 'auto *TdNakedPtr' - // CHECK-FIXES: {{^}} auto *TdNakedPtr = getPtr(); + // CHECK-FIXES: auto *TdNakedPtr = getPtr(); auto TdNakedPtrPtr = getPtrPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto TdNakedPtrPtr' can be declared as 'auto *TdNakedPtrPtr' - // CHECK-FIXES: {{^}} auto *TdNakedPtrPtr = getPtrPtr(); + // CHECK-FIXES: auto *TdNakedPtrPtr = getPtrPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto TdNakedPtrPtr' can be declared as 'auto *TdNakedPtrPtr' - // CHECK-FIXES-ALIAS: {{^}} auto *TdNakedPtrPtr = getPtrPtr(); + // CHECK-FIXES-ALIAS: auto *TdNakedPtrPtr = getPtrPtr(); auto &TdNakedRef = getRef(); auto TdNakedRefDeref = getRef(); auto TdNakedCPtr = getCPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto TdNakedCPtr' can be declared as 'const auto *TdNakedCPtr' - // CHECK-FIXES: {{^}} const auto *TdNakedCPtr = getCPtr(); + // CHECK-FIXES: const auto *TdNakedCPtr = getCPtr(); auto TdNakedCPtrPtr = getCPtrPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto TdNakedCPtrPtr' can be declared as 'auto *TdNakedCPtrPtr' - // CHECK-FIXES: {{^}} auto *TdNakedCPtrPtr = getCPtrPtr(); + // CHECK-FIXES: auto *TdNakedCPtrPtr = getCPtrPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto TdNakedCPtrPtr' can be declared as 'auto *TdNakedCPtrPtr' - // CHECK-FIXES-ALIAS: {{^}} auto *TdNakedCPtrPtr = getCPtrPtr(); + // CHECK-FIXES-ALIAS: auto *TdNakedCPtrPtr = getCPtrPtr(); auto &TdNakedCRef = getCRef(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto &TdNakedCRef' can be declared as 'const auto &TdNakedCRef' - // CHECK-FIXES: {{^}} const auto &TdNakedCRef = getCRef(); + // CHECK-FIXES: const auto &TdNakedCRef = getCRef(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto &TdNakedCRef' can be declared as 'const auto &TdNakedCRef' - // CHECK-FIXES-ALIAS: {{^}} const auto &TdNakedCRef = getCRef(); + // CHECK-FIXES-ALIAS: const auto &TdNakedCRef = getCRef(); auto TdNakedCRefDeref = getCRef(); } @@ -65,22 +65,22 @@ CMyRef getCRef(); void foo() { auto UNakedPtr = getPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto UNakedPtr' can be declared as 'auto *UNakedPtr' - // CHECK-FIXES: {{^}} auto *UNakedPtr = getPtr(); + // CHECK-FIXES: auto *UNakedPtr = getPtr(); auto UNakedPtrPtr = getPtrPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto UNakedPtrPtr' can be declared as 'auto *UNakedPtrPtr' - // CHECK-FIXES: {{^}} auto *UNakedPtrPtr = getPtrPtr(); + // CHECK-FIXES: auto *UNakedPtrPtr = getPtrPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto UNakedPtrPtr' can be declared as 'auto *UNakedPtrPtr' - // CHECK-FIXES-ALIAS: {{^}} auto *UNakedPtrPtr = getPtrPtr(); + // CHECK-FIXES-ALIAS: auto *UNakedPtrPtr = getPtrPtr(); auto &UNakedRef = getRef(); auto UNakedRefDeref = getRef(); auto UNakedCPtr = getCPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto UNakedCPtr' can be declared as 'const auto *UNakedCPtr' - // CHECK-FIXES: {{^}} const auto *UNakedCPtr = getCPtr(); + // CHECK-FIXES: const auto *UNakedCPtr = getCPtr(); auto &UNakedCRef = getCRef(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto &UNakedCRef' can be declared as 'const auto &UNakedCRef' - // CHECK-FIXES: {{^}} const auto &UNakedCRef = getCRef(); + // CHECK-FIXES: const auto &UNakedCRef = getCRef(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto &UNakedCRef' can be declared as 'const auto &UNakedCRef' - // CHECK-FIXES-ALIAS: {{^}} const auto &UNakedCRef = getCRef(); + // CHECK-FIXES-ALIAS: const auto &UNakedCRef = getCRef(); auto UNakedCRefDeref = getCRef(); } @@ -103,68 +103,68 @@ void foo() { auto NakedPtr = getIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto NakedPtr' can be declared as 'auto *NakedPtr' - // CHECK-FIXES: {{^}} auto *NakedPtr = getIntPtr(); + // CHECK-FIXES: auto *NakedPtr = getIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto NakedPtr' can be declared as 'auto *NakedPtr' - // CHECK-FIXES-ALIAS: {{^}} auto *NakedPtr = getIntPtr(); + // CHECK-FIXES-ALIAS: auto *NakedPtr = getIntPtr(); auto NakedCPtr = getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto NakedCPtr' can be declared as 'const auto *NakedCPtr' - // CHECK-FIXES: {{^}} const auto *NakedCPtr = getCIntPtr(); + // CHECK-FIXES: const auto *NakedCPtr = getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto NakedCPtr' can be declared as 'const auto *NakedCPtr' - // CHECK-FIXES-ALIAS: {{^}} const auto *NakedCPtr = getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto *NakedCPtr = getCIntPtr(); const auto ConstPtr = getIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'const auto ConstPtr' can be declared as 'auto *const ConstPtr' - // CHECK-FIXES: {{^}} auto *const ConstPtr = getIntPtr(); + // CHECK-FIXES: auto *const ConstPtr = getIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'const auto ConstPtr' can be declared as 'auto *const ConstPtr' - // CHECK-FIXES-ALIAS: {{^}} auto *const ConstPtr = getIntPtr(); + // CHECK-FIXES-ALIAS: auto *const ConstPtr = getIntPtr(); const auto ConstCPtr = getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'const auto ConstCPtr' can be declared as 'const auto *const ConstCPtr' - // CHECK-FIXES: {{^}} const auto *const ConstCPtr = getCIntPtr(); + // CHECK-FIXES: const auto *const ConstCPtr = getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'const auto ConstCPtr' can be declared as 'const auto *const ConstCPtr' - // CHECK-FIXES-ALIAS: {{^}} const auto *const ConstCPtr = getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto *const ConstCPtr = getCIntPtr(); volatile auto VolatilePtr = getIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'volatile auto VolatilePtr' can be declared as 'auto *volatile VolatilePtr' - // CHECK-FIXES: {{^}} auto *volatile VolatilePtr = getIntPtr(); + // CHECK-FIXES: auto *volatile VolatilePtr = getIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'volatile auto VolatilePtr' can be declared as 'auto *volatile VolatilePtr' - // CHECK-FIXES-ALIAS: {{^}} auto *volatile VolatilePtr = getIntPtr(); + // CHECK-FIXES-ALIAS: auto *volatile VolatilePtr = getIntPtr(); volatile auto VolatileCPtr = getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'volatile auto VolatileCPtr' can be declared as 'const auto *volatile VolatileCPtr' - // CHECK-FIXES: {{^}} const auto *volatile VolatileCPtr = getCIntPtr(); + // CHECK-FIXES: const auto *volatile VolatileCPtr = getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'volatile auto VolatileCPtr' can be declared as 'const auto *volatile VolatileCPtr' - // CHECK-FIXES-ALIAS: {{^}} const auto *volatile VolatileCPtr = getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto *volatile VolatileCPtr = getCIntPtr(); auto *QualPtr = getIntPtr(); auto *QualCPtr = getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto *QualCPtr' can be declared as 'const auto *QualCPtr' - // CHECK-FIXES: {{^}} const auto *QualCPtr = getCIntPtr(); + // CHECK-FIXES: const auto *QualCPtr = getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto *QualCPtr' can be declared as 'const auto *QualCPtr' - // CHECK-FIXES-ALIAS: {{^}} const auto *QualCPtr = getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto *QualCPtr = getCIntPtr(); auto *const ConstantQualCPtr = getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto *const ConstantQualCPtr' can be declared as 'const auto *const ConstantQualCPtr' - // CHECK-FIXES: {{^}} const auto *const ConstantQualCPtr = getCIntPtr(); + // CHECK-FIXES: const auto *const ConstantQualCPtr = getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto *const ConstantQualCPtr' can be declared as 'const auto *const ConstantQualCPtr' - // CHECK-FIXES-ALIAS: {{^}} const auto *const ConstantQualCPtr = getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto *const ConstantQualCPtr = getCIntPtr(); auto *volatile VolatileQualCPtr = getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto *volatile VolatileQualCPtr' can be declared as 'const auto *volatile VolatileQualCPtr' - // CHECK-FIXES: {{^}} const auto *volatile VolatileQualCPtr = getCIntPtr(); + // CHECK-FIXES: const auto *volatile VolatileQualCPtr = getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto *volatile VolatileQualCPtr' can be declared as 'const auto *volatile VolatileQualCPtr' - // CHECK-FIXES-ALIAS: {{^}} const auto *volatile VolatileQualCPtr = getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto *volatile VolatileQualCPtr = getCIntPtr(); const auto *ConstQualCPtr = getCIntPtr(); auto &Ref = *getIntPtr(); auto &CRef = *getCIntPtr(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'auto &CRef' can be declared as 'const auto &CRef' - // CHECK-FIXES: {{^}} const auto &CRef = *getCIntPtr(); + // CHECK-FIXES: const auto &CRef = *getCIntPtr(); // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:3: warning: 'auto &CRef' can be declared as 'const auto &CRef' - // CHECK-FIXES-ALIAS: {{^}} const auto &CRef = *getCIntPtr(); + // CHECK-FIXES-ALIAS: const auto &CRef = *getCIntPtr(); const auto &ConstCRef = *getCIntPtr(); if (auto X = getCIntPtr()) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: 'auto X' can be declared as 'const auto *X' - // CHECK-FIXES: {{^}} if (const auto *X = getCIntPtr()) { + // CHECK-FIXES: if (const auto *X = getCIntPtr()) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:7: warning: 'auto X' can be declared as 'const auto *X' - // CHECK-FIXES-ALIAS: {{^}} if (const auto *X = getCIntPtr()) { + // CHECK-FIXES-ALIAS: if (const auto *X = getCIntPtr()) { } } @@ -201,9 +201,9 @@ void loopRef(std::vector<int> &Mutate, const std::vector<int> &Constant) { } for (auto &Data : Constant) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto &Data' can be declared as 'const auto &Data' - // CHECK-FIXES: {{^}} for (const auto &Data : Constant) { + // CHECK-FIXES: for (const auto &Data : Constant) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:8: warning: 'auto &Data' can be declared as 'const auto &Data' - // CHECK-FIXES-ALIAS: {{^}} for (const auto &Data : Constant) { + // CHECK-FIXES-ALIAS: for (const auto &Data : Constant) { observe(Data); } } @@ -211,16 +211,16 @@ void loopRef(std::vector<int> &Mutate, const std::vector<int> &Constant) { void loopPtr(const std::vector<int *> &Mutate, const std::vector<const int *> &Constant) { for (auto Data : Mutate) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES: {{^}} for (auto *Data : Mutate) { + // CHECK-FIXES: for (auto *Data : Mutate) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:8: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES-ALIAS: {{^}} for (auto *Data : Mutate) { + // CHECK-FIXES-ALIAS: for (auto *Data : Mutate) { change(*Data); } for (auto Data : Constant) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES: {{^}} for (const auto *Data : Constant) { + // CHECK-FIXES: for (const auto *Data : Constant) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:8: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES-ALIAS: {{^}} for (const auto *Data : Constant) { + // CHECK-FIXES-ALIAS: for (const auto *Data : Constant) { observe(*Data); } } @@ -229,17 +229,17 @@ template <typename T> void tempLoopPtr(std::vector<T *> &MutateTemplate, std::vector<const T *> &ConstantTemplate) { for (auto Data : MutateTemplate) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES: {{^}} for (auto *Data : MutateTemplate) { + // CHECK-FIXES: for (auto *Data : MutateTemplate) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:8: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES-ALIAS: {{^}} for (auto *Data : MutateTemplate) { + // CHECK-FIXES-ALIAS: for (auto *Data : MutateTemplate) { change(*Data); } //FixMe for (auto Data : ConstantTemplate) { // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES: {{^}} for (const auto *Data : ConstantTemplate) { + // CHECK-FIXES: for (const auto *Data : ConstantTemplate) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:8: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES-ALIAS: {{^}} for (const auto *Data : ConstantTemplate) { + // CHECK-FIXES-ALIAS: for (const auto *Data : ConstantTemplate) { observe(*Data); } } @@ -250,17 +250,17 @@ public: void operator()(const std::vector<T *> &MClassTemplate, const std::vector<const T *> &CClassTemplate) { for (auto Data : MClassTemplate) { // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES: {{^}} for (auto *Data : MClassTemplate) { + // CHECK-FIXES: for (auto *Data : MClassTemplate) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:10: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES-ALIAS: {{^}} for (auto *Data : MClassTemplate) { + // CHECK-FIXES-ALIAS: for (auto *Data : MClassTemplate) { change(*Data); } //FixMe for (auto Data : CClassTemplate) { // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES: {{^}} for (const auto *Data : CClassTemplate) { + // CHECK-FIXES: for (const auto *Data : CClassTemplate) { // CHECK-MESSAGES-ALIAS: :[[@LINE-3]]:10: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES-ALIAS: {{^}} for (const auto *Data : CClassTemplate) { + // CHECK-FIXES-ALIAS: for (const auto *Data : CClassTemplate) { observe(*Data); } } @@ -285,32 +285,32 @@ functionRetVal getValFunction(); void baz() { auto MyFunctionPtr = getPtrFunction(); // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto MyFunctionPtr' can be declared as 'auto *MyFunctionPtr' - // CHECK-FIXES-NOT: {{^}} auto *MyFunctionPtr = getPtrFunction(); + // CHECK-FIXES-NOT: auto *MyFunctionPtr = getPtrFunction(); // CHECK-MESSAGES-NOT-ALIAS: :[[@LINE-1]]:3: warning: 'auto MyFunctionPtr' can be declared as 'auto *MyFunctionPtr' - // CHECK-FIXES-NOT-ALIAS: {{^}} auto *MyFunctionPtr = getPtrFunction(); + // CHECK-FIXES-NOT-ALIAS: auto *MyFunctionPtr = getPtrFunction(); auto MyFunctionVal = getValFunction(); // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto MyFunctionVal' can be declared as 'auto *MyFunctionVal' - // CHECK-FIXES-NOT: {{^}} auto *MyFunctionVal = getValFunction(); + // CHECK-FIXES-NOT: auto *MyFunctionVal = getValFunction(); // CHECK-MESSAGES-NOT-ALIAS: :[[@LINE-3]]:3: warning: 'auto MyFunctionVal' can be declared as 'auto *MyFunctionVal' - // CHECK-FIXES-NOT-ALIAS: {{^}} auto *MyFunctionVal = getValFunction(); + // CHECK-FIXES-NOT-ALIAS: auto *MyFunctionVal = getValFunction(); auto LambdaTest = [] { return 0; }; // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto LambdaTest' can be declared as 'auto *LambdaTest' - // CHECK-FIXES-NOT: {{^}} auto *LambdaTest = [] { return 0; }; + // CHECK-FIXES-NOT: auto *LambdaTest = [] { return 0; }; // CHECK-MESSAGES-NOT-ALIAS: :[[@LINE-3]]:3: warning: 'auto LambdaTest' can be declared as 'auto *LambdaTest' - // CHECK-FIXES-NOT-ALIAS: {{^}} auto *LambdaTest = [] { return 0; }; + // CHECK-FIXES-NOT-ALIAS: auto *LambdaTest = [] { return 0; }; auto LambdaTest2 = +[] { return 0; }; // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto LambdaTest2' can be declared as 'auto *LambdaTest2' - // CHECK-FIXES-NOT: {{^}} auto *LambdaTest2 = +[] { return 0; }; + // CHECK-FIXES-NOT: auto *LambdaTest2 = +[] { return 0; }; // CHECK-MESSAGES-NOT-ALIAS: :[[@LINE-3]]:3: warning: 'auto LambdaTest2' can be declared as 'auto *LambdaTest2' - // CHECK-FIXES-NOT-ALIAS: {{^}} auto *LambdaTest2 = +[] { return 0; }; + // CHECK-FIXES-NOT-ALIAS: auto *LambdaTest2 = +[] { return 0; }; auto MyFunctionRef = *getPtrFunction(); // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: 'auto MyFunctionRef' can be declared as 'auto *MyFunctionRef' - // CHECK-FIXES-NOT: {{^}} auto *MyFunctionRef = *getPtrFunction(); + // CHECK-FIXES-NOT: auto *MyFunctionRef = *getPtrFunction(); // CHECK-MESSAGES-NOT-ALIAS: :[[@LINE-3]]:3: warning: 'auto MyFunctionRef' can be declared as 'auto *MyFunctionRef' - // CHECK-FIXES-NOT-ALIAS: {{^}} auto *MyFunctionRef = *getPtrFunction(); + // CHECK-FIXES-NOT-ALIAS: auto *MyFunctionRef = *getPtrFunction(); auto &MyFunctionRef2 = *getPtrFunction(); } @@ -456,13 +456,13 @@ void ignored_types_template(std::array<T, 4> arr, const std::array<T, 4>& carr) for (auto Data : arr) { // CHECK-MESSAGES-NOT: warning: 'auto Data' can be declared as 'auto *Data' - // CHECK-FIXES-NOT: {{^}} for (auto *Data : MClassTemplate) { + // CHECK-FIXES-NOT: for (auto *Data : MClassTemplate) { change(*Data); } for (auto Data : carr) { // CHECK-MESSAGES-NOT: warning: 'auto Data' can be declared as 'const auto *Data' - // CHECK-FIXES-NOT: {{^}} for (const auto *Data : MClassTemplate) { + // CHECK-FIXES-NOT: for (const auto *Data : MClassTemplate) { change(*Data); } } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers-check-first-declaration.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers-check-first-declaration.cpp index 88aecbe..58bfd95 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers-check-first-declaration.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers-check-first-declaration.cpp @@ -4,21 +4,21 @@ class FooPublic { private: // comment-0 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers] - // CHECK-FIXES: {{^}}// comment-0{{$}} + // CHECK-FIXES: // comment-0 int a; }; struct StructPublic { public: // comment-1 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers] - // CHECK-FIXES: {{^}}// comment-1{{$}} + // CHECK-FIXES: // comment-1 int a; }; union UnionPublic { public: // comment-2 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers] - // CHECK-FIXES: {{^}}// comment-2{{$}} + // CHECK-FIXES: // comment-2 int a; }; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers.cpp index c1218e3..8c476366e 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers.cpp @@ -6,7 +6,7 @@ public: public: // comment-0 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the previous access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-4]]:1: note: previously declared here - // CHECK-FIXES: {{^}}// comment-0{{$}} + // CHECK-FIXES: // comment-0 int b; private: int c; @@ -18,7 +18,7 @@ public: public: // comment-1 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the previous access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-4]]:1: note: previously declared here - // CHECK-FIXES: {{^}}// comment-1{{$}} + // CHECK-FIXES: // comment-1 int b; private: int c; @@ -30,7 +30,7 @@ public: public: // comment-2 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the previous access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-4]]:1: note: previously declared here - // CHECK-FIXES: {{^}}// comment-2{{$}} + // CHECK-FIXES: // comment-2 int b; private: int c; @@ -42,7 +42,7 @@ protected: protected: // comment-3 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the previous access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-4]]:1: note: previously declared here - // CHECK-FIXES: {{^}}// comment-3{{$}} + // CHECK-FIXES: // comment-3 int b; private: int c; @@ -54,7 +54,7 @@ private: private: // comment-4 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the previous access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-4]]:1: note: previously declared here - // CHECK-FIXES: {{^}}// comment-4{{$}} + // CHECK-FIXES: // comment-4 int b; public: int c; @@ -70,7 +70,7 @@ private: private: // comment-5 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the previous access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-8]]:1: note: previously declared here - // CHECK-FIXES: {{^}}// comment-5{{$}} + // CHECK-FIXES: // comment-5 int c; protected: int d; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp index 9c3c90b..fa91995 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp @@ -22,35 +22,35 @@ void testRedundantStaticCasting(A& value) { A& a1 = static_cast<A&>(value); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:36: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} A& a1 = value; + // CHECK-FIXES: A& a1 = value; } void testRedundantConstCasting1(A& value) { A& a2 = const_cast<A&>(value); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:36: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} A& a2 = value; + // CHECK-FIXES: A& a2 = value; } void testRedundantConstCasting2(const A& value) { const A& a3 = const_cast<const A&>(value); // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: redundant explicit casting to the same type 'const A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:42: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} const A& a3 = value; + // CHECK-FIXES: const A& a3 = value; } void testRedundantReinterpretCasting(A& value) { A& a4 = reinterpret_cast<A&>(value); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:41: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} A& a4 = value; + // CHECK-FIXES: A& a4 = value; } void testRedundantCCasting(A& value) { A& a5 = (A&)(value); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:31: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} A& a5 = value; + // CHECK-FIXES: A& a5 = value; } void testDoubleCasting(A& value) { @@ -58,7 +58,7 @@ void testDoubleCasting(A& value) { // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-4]]:27: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} A& a6 = value; + // CHECK-FIXES: A& a6 = value; } void testDiffrentTypesCast(B& value) { @@ -76,7 +76,7 @@ void testCastingWithAuto() { A& a8 = static_cast<A&>(a); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:8: note: source type originates from referencing this variable - // CHECK-FIXES: {{^}} A& a8 = a; + // CHECK-FIXES: A& a8 = a; } void testCastingWithConstAuto() { @@ -84,7 +84,7 @@ void testCastingWithConstAuto() { const A& a9 = static_cast<const A&>(a); // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: redundant explicit casting to the same type 'const A' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:14: note: source type originates from referencing this variable - // CHECK-FIXES: {{^}} const A& a9 = a; + // CHECK-FIXES: const A& a9 = a; } void testCastingWithAutoPtr(A& ptr) { @@ -92,7 +92,7 @@ void testCastingWithAutoPtr(A& ptr) { A* a10 = static_cast<A*>(a); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant explicit casting to the same type 'A *' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-3]]:9: note: source type originates from referencing this variable - // CHECK-FIXES: {{^}} A* a10 = a; + // CHECK-FIXES: A* a10 = a; } template<typename T> @@ -101,7 +101,7 @@ void testRedundantTemplateCasting(T& value) { T& t = static_cast<T&>(value); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: redundant explicit casting to the same type 'T' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-4]]:38: note: source type originates from referencing this parameter - // CHECK-FIXES: {{^}} T& t = value; + // CHECK-FIXES: T& t = value; } void testTemplate() { @@ -130,7 +130,7 @@ void testMacroCasting(int value) { void testMacroCasting(A* PTR_NAME) { A* a13 = static_cast<A*>(PTR_NAME); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant explicit casting to the same type 'A *' as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES: {{^}} A* a13 = PTR_NAME; + // CHECK-FIXES: A* a13 = PTR_NAME; } struct CastBool { @@ -148,19 +148,19 @@ using TypeA = A; void testTypedefCast(A& value) { TypeA& a = static_cast<TypeA&>(value); // CHECK-MESSAGES-ALIASES: :[[@LINE-1]]:14: warning: redundant explicit casting to the same type 'TypeA' (aka 'A') as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES-ALIASES: {{^}} TypeA& a = value; + // CHECK-FIXES-ALIASES: TypeA& a = value; } void testTypedefCast2(TypeA& value) { A& a = static_cast<A&>(value); // CHECK-MESSAGES-ALIASES: :[[@LINE-1]]:10: warning: redundant explicit casting to the same type 'A' as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES-ALIASES: {{^}} A& a = value; + // CHECK-FIXES-ALIASES: A& a = value; } void testFunctionalCastWithPrimitive(int a) { int b = int(a); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'int' as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES: {{^}} int b = a; + // CHECK-FIXES: int b = a; } void testFunctionalCastWithInitExpr(unsigned a) { @@ -190,7 +190,7 @@ struct Class { return static_cast<Iterator>(first()); // CHECK-MESSAGES-ALIASES: :[[@LINE-1]]:12: warning: redundant explicit casting to the same type 'Iterator' (aka 'const char *') as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES-ALIASES: :[[@LINE+4]]:15: note: source type originates from the invocation of this method -// CHECK-FIXES-ALIASES: {{^}} return first(); +// CHECK-FIXES-ALIASES: return first(); } const char* first(); @@ -199,20 +199,20 @@ struct Class { void testAddOperation(int aa, int bb) { int c = static_cast<int>(aa + bb) * aa; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'int' as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES: {{^}} int c = (aa + bb) * aa; + // CHECK-FIXES: int c = (aa + bb) * aa; } void testAddOperationWithParen(int a, int b) { int c = static_cast<int>((a+b))*a; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'int' as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES: {{^}} int c = (a+b)*a; + // CHECK-FIXES: int c = (a+b)*a; } void testRValueCast(int&& a) { int&& b = static_cast<int&&>(a); int&& c = static_cast<int&&>(10); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant explicit casting to the same type 'int' as the sub-expression, remove this casting [readability-redundant-casting] - // CHECK-FIXES: {{^}} int&& c = 10; + // CHECK-FIXES: int&& c = 10; } template <int V> @@ -220,7 +220,7 @@ void testRedundantNTTPCasting() { int a = static_cast<int>(V); // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant explicit casting to the same type 'int' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-4]]:15: note: source type originates from referencing this non-type template parameter - // CHECK-FIXES: {{^}} int a = V; + // CHECK-FIXES: int a = V; } template <typename T, T V> @@ -233,5 +233,5 @@ void testRedundantDependentNTTPCasting() { T a = static_cast<T>(V); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant explicit casting to the same type 'T' as the sub-expression, remove this casting [readability-redundant-casting] // CHECK-MESSAGES: :[[@LINE-4]]:25: note: source type originates from referencing this non-type template parameter - // CHECK-FIXES: {{^}} T a = V; + // CHECK-FIXES: T a = V; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-control-flow.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-control-flow.cpp index 0352e3a..7764490 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-control-flow.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-control-flow.cpp @@ -7,7 +7,7 @@ void f() { return; } // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: redundant return statement at the end of a function with a void return type [readability-redundant-control-flow] -// CHECK-FIXES: {{^}}void f() {{{$}} +// CHECK-FIXES: void f() { // CHECK-FIXES-NEXT: {{^ *}$}} void g() { @@ -15,7 +15,7 @@ void g() { return; } // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: redundant return statement -// CHECK-FIXES: {{^ }}f();{{$}} +// CHECK-FIXES: f(); // CHECK-FIXES-NEXT: {{^ *}$}} void g(int i) { @@ -40,7 +40,7 @@ void k() { } } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: redundant continue statement at the end of loop statement -// CHECK-FIXES: {{^}} for (int i = 0; i < 10; ++i) {{{$}} +// CHECK-FIXES: for (int i = 0; i < 10; ++i) { // CHECK-FIXES-NEXT: {{^ *}$}} void k2() { @@ -50,7 +50,7 @@ void k2() { } } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: redundant continue statement -// CHECK-FIXES: {{^}} for (auto i : v) {{{$}} +// CHECK-FIXES: for (auto i : v) { // CHECK-FIXES-NEXT: {{^ *}$}} void m() { @@ -62,8 +62,8 @@ void m() { } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: redundant continue statement // CHECK-FIXES: {{^ do {$}} -// CHECK-FIXES-NEXT: {{^}} ++i;{{$}} -// CHECK-FIXES-NEXT: {{^ *}}} while (i < 10);{{$}} +// CHECK-FIXES-NEXT: ++i; +// CHECK-FIXES-NEXT: } while (i < 10); void p() { int i = 0; @@ -73,8 +73,8 @@ void p() { } } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: redundant continue statement -// CHECK-FIXES: {{^}} while (i < 10) {{{$}} -// CHECK-FIXES-NEXT: {{^}} ++i;{{$}} +// CHECK-FIXES: while (i < 10) { +// CHECK-FIXES-NEXT: ++i; // CHECK-FIXES-NEXT: {{^ *}$}} void im_not_dead(int i) { @@ -176,7 +176,7 @@ void template_return(T check) { return; } // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: redundant return statement -// CHECK-FIXES: {{^}} if (check < T(0)) {{{$}} +// CHECK-FIXES: if (check < T(0)) { // CHECK-FIXES-NEXT: {{^ return;$}} // CHECK-FIXES-NEXT: {{^ *}$}} // CHECK-FIXES-NEXT: {{^ *}$}} @@ -189,7 +189,7 @@ void template_return(int check) { return; } // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: redundant return statement -// CHECK-FIXES: {{^}} if (check < 0) {{{$}} +// CHECK-FIXES: if (check < 0) { // CHECK-FIXES-NEXT: {{^ return;$}} // CHECK-FIXES-NEXT: {{^ *}$}} // CHECK-FIXES-NEXT: {{^ *}$}} @@ -201,7 +201,7 @@ void template_loop(T end) { } } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: redundant continue statement -// CHECK-FIXES: {{^}} for (T i = 0; i < end; ++i) {{{$}} +// CHECK-FIXES: for (T i = 0; i < end; ++i) { // CHECK-FIXES-NEXT: {{^ *}$}} template <> @@ -211,7 +211,7 @@ void template_loop(int end) { } } // CHECK-MESSAGES: :[[@LINE-3]]:5: warning: redundant continue statement -// CHECK-FIXES: {{^}} for (int i = 0; i < end; ++i) {{{$}} +// CHECK-FIXES: for (int i = 0; i < end; ++i) { // CHECK-FIXES-NEXT: {{^ *}$}} void call_templates() { diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.c b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.c index dbcc4cf..5e86afc 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.c +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.c @@ -3,23 +3,23 @@ extern int Xyz; extern int Xyz; // Xyz // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration] -// CHECK-FIXES: {{^}}// Xyz{{$}} +// CHECK-FIXES: // Xyz int Xyz = 123; extern int A; extern int A, B; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'A' declaration -// CHECK-FIXES: {{^}}extern int A, B;{{$}} +// CHECK-FIXES: extern int A, B; extern int Buf[10]; extern int Buf[10]; // Buf[10] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Buf' declaration -// CHECK-FIXES: {{^}}// Buf[10]{{$}} +// CHECK-FIXES: // Buf[10] static int f(void); static int f(void); // f // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'f' declaration -// CHECK-FIXES: {{^}}// f{{$}} +// CHECK-FIXES: // f static int f(void) { return 0; } inline void g(void) {} diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.cpp index 595eccf..975742d 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-declaration.cpp @@ -21,23 +21,23 @@ extern int Xyz; extern int Xyz; // Xyz // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration] -// CHECK-FIXES: {{^}}// Xyz{{$}} +// CHECK-FIXES: // Xyz int Xyz = 123; extern int A; extern int A, B; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'A' declaration -// CHECK-FIXES: {{^}}extern int A, B;{{$}} +// CHECK-FIXES: extern int A, B; extern int Buf[10]; extern int Buf[10]; // Buf[10] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Buf' declaration -// CHECK-FIXES: {{^}}// Buf[10]{{$}} +// CHECK-FIXES: // Buf[10] static int f(); static int f(); // f // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'f' declaration -// CHECK-FIXES: {{^}}// f{{$}} +// CHECK-FIXES: // f static int f() { return 0; } // Original check crashed for the code below. @@ -102,10 +102,10 @@ namespace macros { DECLARE(test); DEFINE(test); // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: redundant 'test' declaration -// CHECK-FIXES: {{^}}#define DECLARE(x) extern int x{{$}} -// CHECK-FIXES: {{^}}#define DEFINE(x) extern int x; int x = 42{{$}} -// CHECK-FIXES: {{^}}DECLARE(test);{{$}} -// CHECK-FIXES: {{^}}DEFINE(test);{{$}} +// CHECK-FIXES: #define DECLARE(x) extern int x +// CHECK-FIXES: #define DEFINE(x) extern int x; int x = 42 +// CHECK-FIXES: DECLARE(test); +// CHECK-FIXES: DEFINE(test); } // namespace macros @@ -113,16 +113,16 @@ inline void g() {} inline void g(); // g // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant 'g' declaration -// CHECK-FIXES: {{^}}// g{{$}} +// CHECK-FIXES: // g #if defined(EXTERNINLINE) extern inline void g(); // extern g // CHECK-MESSAGES-NOMSCOMPAT: :[[@LINE-1]]:20: warning: redundant 'g' declaration -// CHECK-FIXES-NOMSCOMPAT: {{^}}// extern g{{$}} +// CHECK-FIXES-NOMSCOMPAT: // extern g #endif // PR42068 extern "C" int externX; int dummyBeforeBegin;extern "C" int externX;int dummyAfterEnd; // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: redundant 'externX' declaration [readability-redundant-declaration] -// CHECK-FIXES: {{^}}int dummyBeforeBegin;int dummyAfterEnd;{{$}} +// CHECK-FIXES: int dummyBeforeBegin;int dummyAfterEnd; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-member-init.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-member-init.cpp index 6f18a60..0eebac8 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-member-init.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-member-init.cpp @@ -146,7 +146,7 @@ WithCopyConstructor2::WithCopyConstructor2(const WithCopyConstructor2& other) {} // No warning in copy constructor about T since IgnoreBaseInCopyConstructors=1 // CHECK-MESSAGES: :[[@LINE-3]]:10: warning: initializer for member 'a' is redundant -// CHECK-FIXES: {{^}} : T() {{$}} +// CHECK-FIXES: : T() // CHECK-NEXT: {} // Initializer not written diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-format.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-format.cpp index e58c8d8..a2bbd19 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-format.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-format.cpp @@ -57,35 +57,35 @@ std::wstring return_wtemporary(); void std_format(const std::string &s1, const std::string &s2, const std::string &s3) { auto r1 = std::format("One:{}\n", s1.c_str()); // CHECK-MESSAGES-STDFORMAT: :[[@LINE-1]]:37: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDFORMAT: {{^ }}auto r1 = std::format("One:{}\n", s1); + // CHECK-FIXES-STDFORMAT: auto r1 = std::format("One:{}\n", s1); auto r2 = std::format("One:{} Two:{} Three:{} Four:{}\n", s1.c_str(), s2, s3.c_str(), return_temporary().c_str()); // CHECK-MESSAGES-STDFORMAT: :[[@LINE-1]]:61: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDFORMAT: :[[@LINE-2]]:77: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDFORMAT: :[[@LINE-3]]:89: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDFORMAT: {{^ }}auto r2 = std::format("One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_temporary()); + // CHECK-FIXES-STDFORMAT: auto r2 = std::format("One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_temporary()); using namespace std; auto r3 = format("Four:{}\n", s1.c_str()); // CHECK-MESSAGES-STDFORMAT: :[[@LINE-1]]:33: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDFORMAT: {{^ }}auto r3 = format("Four:{}\n", s1); + // CHECK-FIXES-STDFORMAT: auto r3 = format("Four:{}\n", s1); } void std_format_wide(const std::wstring &s1, const std::wstring &s2, const std::wstring &s3) { auto r1 = std::format(L"One:{}\n", s1.c_str()); // CHECK-MESSAGES-STDFORMAT: :[[@LINE-1]]:38: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDFORMAT: {{^ }}auto r1 = std::format(L"One:{}\n", s1); + // CHECK-FIXES-STDFORMAT: auto r1 = std::format(L"One:{}\n", s1); auto r2 = std::format(L"One:{} Two:{} Three:{} Four:{}\n", s1.c_str(), s2, s3.c_str(), return_wtemporary().c_str()); // CHECK-MESSAGES-STDFORMAT: :[[@LINE-1]]:62: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDFORMAT: :[[@LINE-2]]:78: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDFORMAT: :[[@LINE-3]]:90: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDFORMAT: {{^ }}auto r2 = std::format(L"One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_wtemporary()); + // CHECK-FIXES-STDFORMAT: auto r2 = std::format(L"One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_wtemporary()); using namespace std; auto r3 = format(L"Four:{}\n", s1.c_str()); // CHECK-MESSAGES-STDFORMAT: :[[@LINE-1]]:34: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDFORMAT: {{^ }}auto r3 = format(L"Four:{}\n", s1); + // CHECK-FIXES-STDFORMAT: auto r3 = format(L"Four:{}\n", s1); } // There's are c_str() calls here, so it shouldn't be touched. @@ -119,35 +119,35 @@ std::string not_std_format_wide(const std::string &s1) { void std_print(const std::string &s1, const std::string &s2, const std::string &s3) { std::print("One:{}\n", s1.c_str()); // CHECK-MESSAGES-STDPRINT: :[[@LINE-1]]:26: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDPRINT: {{^ }}std::print("One:{}\n", s1); + // CHECK-FIXES-STDPRINT: std::print("One:{}\n", s1); std::print("One:{} Two:{} Three:{} Four:{}\n", s1.c_str(), s2, s3.c_str(), return_temporary().c_str()); // CHECK-MESSAGES-STDPRINT: :[[@LINE-1]]:50: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDPRINT: :[[@LINE-2]]:66: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDPRINT: :[[@LINE-3]]:78: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDPRINT: {{^ }}std::print("One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_temporary()); + // CHECK-FIXES-STDPRINT: std::print("One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_temporary()); using namespace std; print("Four:{}\n", s1.c_str()); // CHECK-MESSAGES-STDPRINT: :[[@LINE-1]]:22: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDPRINT: {{^ }}print("Four:{}\n", s1); + // CHECK-FIXES-STDPRINT: print("Four:{}\n", s1); } void std_print_wide(const std::wstring &s1, const std::wstring &s2, const std::wstring &s3) { std::print(L"One:{}\n", s1.c_str()); // CHECK-MESSAGES-STDPRINT: :[[@LINE-1]]:27: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDPRINT: {{^ }}std::print(L"One:{}\n", s1); + // CHECK-FIXES-STDPRINT: std::print(L"One:{}\n", s1); std::print(L"One:{} Two:{} Three:{} Four:{}\n", s1.c_str(), s2, s3.c_str(), return_wtemporary().c_str()); // CHECK-MESSAGES-STDPRINT: :[[@LINE-1]]:51: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDPRINT: :[[@LINE-2]]:67: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES-STDPRINT: :[[@LINE-3]]:79: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDPRINT: {{^ }}std::print(L"One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_wtemporary()); + // CHECK-FIXES-STDPRINT: std::print(L"One:{} Two:{} Three:{} Four:{}\n", s1, s2, s3, return_wtemporary()); using namespace std; print(L"Four:{}\n", s1.c_str()); // CHECK-MESSAGES-STDPRINT: :[[@LINE-1]]:23: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES-STDPRINT: {{^ }}print(L"Four:{}\n", s1); + // CHECK-FIXES-STDPRINT: print(L"Four:{}\n", s1); } // There's no c_str() call here, so it shouldn't be touched. diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-function.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-function.cpp index bc12fd5..57a70f7 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-function.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-function.cpp @@ -27,12 +27,12 @@ namespace notfmt { void fmt_print(const std::string &s1, const std::string &s2, const std::string &s3) { fmt::print("One:{}\n", s1.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}fmt::print("One:{}\n", s1); + // CHECK-FIXES: fmt::print("One:{}\n", s1); fmt::print("One:{} Two:{} Three:{}\n", s1.c_str(), s2, s3.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:58: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}fmt::print("One:{} Two:{} Three:{}\n", s1, s2, s3); + // CHECK-FIXES: fmt::print("One:{} Two:{} Three:{}\n", s1, s2, s3); } // There's no c_str() call here, so it shouldn't be touched @@ -48,12 +48,12 @@ void not_fmt_print(const std::string &s1) { void fmt_format(const std::string &s1, const std::string &s2, const std::string &s3) { auto r1 = fmt::format("One:{}\n", s1.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}auto r1 = fmt::format("One:{}\n", s1); + // CHECK-FIXES: auto r1 = fmt::format("One:{}\n", s1); auto r2 = fmt::format("One:{} Two:{} Three:{}\n", s1.c_str(), s2, s3.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:69: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}auto r2 = fmt::format("One:{} Two:{} Three:{}\n", s1, s2, s3); + // CHECK-FIXES: auto r2 = fmt::format("One:{} Two:{} Three:{}\n", s1, s2, s3); } // There's are c_str() calls here, so it shouldn't be touched @@ -87,25 +87,25 @@ void logger1(const std::string &s1, const std::string &s2, const std::string &s3 LOGGER("%s\n", s1.c_str(), s2, s3.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:34: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}LOGGER("%s\n", s1, s2, s3); + // CHECK-FIXES: LOGGER("%s\n", s1, s2, s3); DerivedLogger LOGGER2; LOGGER2("%d %s\n", 42, s1.c_str(), s2.c_str(), s3); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:38: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}LOGGER2("%d %s\n", 42, s1, s2, s3); + // CHECK-FIXES: LOGGER2("%d %s\n", 42, s1, s2, s3); DoubleDerivedLogger LOGGERD; LOGGERD("%d %s\n", 42, s1.c_str(), s2, s3.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:42: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}LOGGERD("%d %s\n", 42, s1, s2, s3); + // CHECK-FIXES: LOGGERD("%d %s\n", 42, s1, s2, s3); TypedefDerivedLogger LOGGERT; LOGGERT("%d %s\n", 42, s1.c_str(), s2, s3.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:42: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}LOGGERT("%d %s\n", 42, s1, s2, s3); + // CHECK-FIXES: LOGGERT("%d %s\n", 42, s1, s2, s3); } void logger2(const std::string &s1, const std::string &s2) { @@ -114,13 +114,13 @@ void logger2(const std::string &s1, const std::string &s2) { LOGGER3.Log("%s\n", s1.c_str(), s2.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:35: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}LOGGER3.Log("%s\n", s1, s2); + // CHECK-FIXES: LOGGER3.Log("%s\n", s1, s2); DerivedLogger LOGGER4; LOGGER4.Log("%d %s\n", 42, s1.c_str(), s2.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: redundant call to 'c_str' [readability-redundant-string-cstr] // CHECK-MESSAGES: :[[@LINE-2]]:42: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}LOGGER4.Log("%d %s\n", 42, s1, s2); + // CHECK-FIXES: LOGGER4.Log("%d %s\n", 42, s1, s2); } class NotLogger { diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-msvc.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-msvc.cpp index a6b6b20..28da8a7 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-msvc.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr-msvc.cpp @@ -26,22 +26,22 @@ struct StringRef { void f1(const std::string &s) { f1(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f1(s);{{$}} + // CHECK-FIXES: f1(s); f1(s.data()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'data' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f1(s);{{$}} + // CHECK-FIXES: f1(s); } void f2(const llvm::StringRef r) { std::string s; f2(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}std::string s;{{$}} - // CHECK-FIXES-NEXT: {{^ }}f2(s);{{$}} + // CHECK-FIXES: std::string s; + // CHECK-FIXES-NEXT: f2(s); } void f3(const llvm::StringRef &r) { std::string s; f3(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}std::string s;{{$}} - // CHECK-FIXES-NEXT: {{^ }}f3(s);{{$}} + // CHECK-FIXES: std::string s; + // CHECK-FIXES-NEXT: f3(s); } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr.cpp index 5dc138e..0c393f2 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-string-cstr.cpp @@ -19,83 +19,83 @@ struct StringRef { void f1(const std::string &s) { f1(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f1(s);{{$}} + // CHECK-FIXES: f1(s); f1(s.data()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'data' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f1(s);{{$}} + // CHECK-FIXES: f1(s); } void f2(const llvm::StringRef r) { std::string s; f2(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}std::string s;{{$}} - // CHECK-FIXES-NEXT: {{^ }}f2(s);{{$}} + // CHECK-FIXES: std::string s; + // CHECK-FIXES-NEXT: f2(s); } void f3(const llvm::StringRef &r) { std::string s; f3(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}std::string s;{{$}} - // CHECK-FIXES-NEXT: {{^ }}f3(s);{{$}} + // CHECK-FIXES: std::string s; + // CHECK-FIXES-NEXT: f3(s); } void f4(const std::string &s) { const std::string* ptr = &s; f1(ptr->c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f1(*ptr);{{$}} + // CHECK-FIXES: f1(*ptr); } void f5(const std::string &s) { std::string tmp; tmp.append(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp.append(s);{{$}} + // CHECK-FIXES: tmp.append(s); tmp.assign(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp.assign(s);{{$}} + // CHECK-FIXES: tmp.assign(s); if (tmp.compare(s.c_str()) == 0) return; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}if (tmp.compare(s) == 0) return;{{$}} + // CHECK-FIXES: if (tmp.compare(s) == 0) return; if (tmp.compare(1, 2, s.c_str()) == 0) return; // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}if (tmp.compare(1, 2, s) == 0) return;{{$}} + // CHECK-FIXES: if (tmp.compare(1, 2, s) == 0) return; if (tmp.find(s.c_str()) == 0) return; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}if (tmp.find(s) == 0) return;{{$}} + // CHECK-FIXES: if (tmp.find(s) == 0) return; if (tmp.find(s.c_str(), 2) == 0) return; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}if (tmp.find(s, 2) == 0) return;{{$}} + // CHECK-FIXES: if (tmp.find(s, 2) == 0) return; if (tmp.find(s.c_str(), 2) == 0) return; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}if (tmp.find(s, 2) == 0) return;{{$}} + // CHECK-FIXES: if (tmp.find(s, 2) == 0) return; tmp.insert(1, s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp.insert(1, s);{{$}} + // CHECK-FIXES: tmp.insert(1, s); tmp = s.c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp = s;{{$}} + // CHECK-FIXES: tmp = s; tmp += s.c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp += s;{{$}} + // CHECK-FIXES: tmp += s; if (tmp == s.c_str()) return; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}if (tmp == s) return;{{$}} + // CHECK-FIXES: if (tmp == s) return; tmp = s + s.c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp = s + s;{{$}} + // CHECK-FIXES: tmp = s + s; tmp = s.c_str() + s; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant call {{.*}} - // CHECK-FIXES: {{^ }}tmp = s + s;{{$}} + // CHECK-FIXES: tmp = s + s; } void f6(const std::string &s) { std::string tmp; @@ -122,10 +122,10 @@ void f7(std::string_view sv) { std::string s; f7(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f7(s);{{$}} + // CHECK-FIXES: f7(s); f7(s.data()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'data' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}f7(s);{{$}} + // CHECK-FIXES: f7(s); } // Tests for std::wstring. @@ -133,16 +133,16 @@ void f7(std::string_view sv) { void g1(const std::wstring &s) { g1(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}g1(s);{{$}} + // CHECK-FIXES: g1(s); } void g2(std::wstring_view sv) { std::wstring s; g2(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}g2(s);{{$}} + // CHECK-FIXES: g2(s); g2(s.data()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'data' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}g2(s);{{$}} + // CHECK-FIXES: g2(s); } // Tests for std::u16string. @@ -150,16 +150,16 @@ void g2(std::wstring_view sv) { void h1(const std::u16string &s) { h1(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}h1(s);{{$}} + // CHECK-FIXES: h1(s); } void h2(std::u16string_view sv) { std::u16string s; h2(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}h2(s);{{$}} + // CHECK-FIXES: h2(s); h2(s.data()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'data' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}h2(s);{{$}} + // CHECK-FIXES: h2(s); } // Tests for std::u32string. @@ -167,16 +167,16 @@ void h2(std::u16string_view sv) { void k1(const std::u32string &s) { k1(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}k1(s);{{$}} + // CHECK-FIXES: k1(s); } void k2(std::u32string_view sv) { std::u32string s; k2(s.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}k2(s);{{$}} + // CHECK-FIXES: k2(s); k2(s.data()); // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: redundant call to 'data' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}k2(s);{{$}} + // CHECK-FIXES: k2(s); } // Tests on similar classes that aren't good candidates for this checker. @@ -214,23 +214,23 @@ void it(iterator<std::string> i) std::string tmp; tmp = i->c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}tmp = *i;{{$}} + // CHECK-FIXES: tmp = *i; // An unlikely situation and the outcome is not ideal, but at least the fix doesn't generate broken code. tmp = i.operator->()->c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}tmp = *i.operator->();{{$}} + // CHECK-FIXES: tmp = *i.operator->(); // The fix contains an unnecessary set of parentheses, but these have no effect. iterator<std::string> *pi = &i; tmp = (*pi)->c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}tmp = *(*pi);{{$}} + // CHECK-FIXES: tmp = *(*pi); // An unlikely situation, but at least the fix doesn't generate broken code. tmp = pi->operator->()->c_str(); // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}tmp = *pi->operator->();{{$}} + // CHECK-FIXES: tmp = *pi->operator->(); } namespace PR45286 { @@ -244,7 +244,7 @@ void bar() { Foo Foo; Foo.func(Str.c_str()); // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}Foo.func(Str);{{$}} + // CHECK-FIXES: Foo.func(Str); // Ensure it doesn't transform Binding to r values Foo.func2(Str.c_str()); @@ -252,7 +252,7 @@ void bar() { // Ensure its not confused by parens Foo.func((Str.c_str())); // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant call to 'c_str' [readability-redundant-string-cstr] - // CHECK-FIXES: {{^ }}Foo.func((Str));{{$}} + // CHECK-FIXES: Foo.func((Str)); Foo.func2((Str.c_str())); } } // namespace PR45286 diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-assignment.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-assignment.cpp index d72f182..0f02e3f 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-assignment.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-assignment.cpp @@ -12,9 +12,9 @@ void chained_conditional_compound_assignment(int i) { b = false; } // CHECK-MESSAGES: :[[@LINE-4]]:9: warning: redundant boolean literal in conditional assignment [readability-simplify-boolean-expr] - // CHECK-FIXES: {{^}} } else if (i < 10) {{{$}} - // CHECK-FIXES-NEXT: {{^}} b = false;{{$}} - // CHECK-FIXES-NEXT: {{^}} } else b = i > 20;{{$}} + // CHECK-FIXES: } else if (i < 10) { + // CHECK-FIXES-NEXT: b = false; + // CHECK-FIXES-NEXT: } else b = i > 20; } void chained_conditional_assignment(int i) { @@ -28,7 +28,7 @@ void chained_conditional_assignment(int i) { else b = false; // CHECK-MESSAGES: :[[@LINE-3]]:9: warning: {{.*}} in conditional assignment - // CHECK-FIXES: {{^}} else if (i < 10) - // CHECK-FIXES-NEXT: {{^}} b = false; - // CHECK-FIXES-NEXT: {{^}} else b = i > 20; + // CHECK-FIXES: else if (i < 10) + // CHECK-FIXES-NEXT: b = false; + // CHECK-FIXES-NEXT: else b = i > 20; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-return.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-return.cpp index fb99935..1658212 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-return.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-chained-conditional-return.cpp @@ -11,9 +11,9 @@ bool chained_conditional_compound_return(int i) { return false; } // CHECK-MESSAGES: :[[@LINE-4]]:12: warning: redundant boolean literal in conditional return statement [readability-simplify-boolean-expr] - // CHECK-FIXES: {{^}} } else if (i < 10) {{{$}} - // CHECK-FIXES-NEXT: {{^}} return false;{{$}} - // CHECK-FIXES-NEXT: {{^}} } else return i > 20;{{$}} + // CHECK-FIXES: } else if (i < 10) { + // CHECK-FIXES-NEXT: return false; + // CHECK-FIXES-NEXT: } else return i > 20; } bool chained_conditional_return(int i) { @@ -26,9 +26,9 @@ bool chained_conditional_return(int i) { else return false; // CHECK-MESSAGES: :[[@LINE-3]]:12: warning: {{.*}} in conditional return statement - // CHECK-FIXES: {{^}} else if (i < 10) - // CHECK-FIXES-NEXT: {{^}} return false; - // CHECK-FIXES-NEXT: {{^}} else return i > 20; + // CHECK-FIXES: else if (i < 10) + // CHECK-FIXES-NEXT: return false; + // CHECK-FIXES-NEXT: else return i > 20; } bool chained_simple_if_return(int i) { @@ -39,11 +39,11 @@ bool chained_simple_if_return(int i) { return false; } // CHECK-MESSAGES: :[[@LINE-3]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: {{^}}bool chained_simple_if_return(int i) {{{$}} -// CHECK-FIXES: {{^}} if (i < 5){{$}} -// CHECK-FIXES: {{^ return true;$}} -// CHECK-FIXES: {{^ return i > 10;$}} -// CHECK-FIXES: {{^}$}} +// CHECK-FIXES: bool chained_simple_if_return(int i) { +// CHECK-FIXES: if (i < 5) +// CHECK-FIXES: return true; +// CHECK-FIXES: return i > 10; +// CHECK-FIXES: } bool chained_simple_if_return_negated(int i) { if (i < 5) @@ -53,11 +53,11 @@ bool chained_simple_if_return_negated(int i) { return true; } // CHECK-MESSAGES: :[[@LINE-3]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: {{^}}bool chained_simple_if_return_negated(int i) {{{$}} -// CHECK-FIXES: {{^}} if (i < 5){{$}} -// CHECK-FIXES: {{^ return false;$}} -// CHECK-FIXES: {{^ return i <= 10;$}} -// CHECK-FIXES: {{^}$}} +// CHECK-FIXES: bool chained_simple_if_return_negated(int i) { +// CHECK-FIXES: if (i < 5) +// CHECK-FIXES: return false; +// CHECK-FIXES: return i <= 10; +// CHECK-FIXES: } bool complex_chained_if_return_return(int i) { if (i < 5) { @@ -69,12 +69,12 @@ bool complex_chained_if_return_return(int i) { return false; } // CHECK-MESSAGES: :[[@LINE-4]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: {{^}}bool complex_chained_if_return_return(int i) {{{$}} -// CHECK-FIXES: {{^}} if (i < 5) {{{$}} -// CHECK-FIXES: {{^}} return true;{{$}} -// CHECK-FIXES: {{^}} }{{$}} -// CHECK-FIXES: {{^ return i > 10;$}} -// CHECK-FIXES: {{^}$}} +// CHECK-FIXES: bool complex_chained_if_return_return(int i) { +// CHECK-FIXES: if (i < 5) { +// CHECK-FIXES: return true; +// CHECK-FIXES: } +// CHECK-FIXES: return i > 10; +// CHECK-FIXES: } bool complex_chained_if_return_return_negated(int i) { if (i < 5) { @@ -86,12 +86,12 @@ bool complex_chained_if_return_return_negated(int i) { return true; } // CHECK-MESSAGES: :[[@LINE-4]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: {{^}}bool complex_chained_if_return_return_negated(int i) {{{$}} -// CHECK-FIXES: {{^}} if (i < 5) {{{$}} -// CHECK-FIXES: {{^}} return false;{{$}} -// CHECK-FIXES: {{^}} }{{$}} -// CHECK-FIXES: {{^ return i <= 10;$}} -// CHECK-FIXES: {{^}$}} +// CHECK-FIXES: bool complex_chained_if_return_return_negated(int i) { +// CHECK-FIXES: if (i < 5) { +// CHECK-FIXES: return false; +// CHECK-FIXES: } +// CHECK-FIXES: return i <= 10; +// CHECK-FIXES: } bool PR57819(int x) { diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-members.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-members.cpp index 7f71b7b..83f2fa9 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-members.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/simplify-boolean-expr-members.cpp @@ -42,7 +42,7 @@ void S::operator_equals() { m_b1 = (i > 2); if (m_b1 == true) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b1\) {$}} + // CHECK-FIXES: if (m_b1) { i = 5; } else { i = 6; @@ -50,7 +50,7 @@ void S::operator_equals() { m_b2 = (i > 4); if (m_b2 == false) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(!m_b2\) {$}} + // CHECK-FIXES: if (!m_b2) { i = 7; } else { i = 9; @@ -58,7 +58,7 @@ void S::operator_equals() { m_b3 = (i > 6); if (true == m_b3) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b3\) {$}} + // CHECK-FIXES: if (m_b3) { i = 10; } else { i = 11; @@ -66,7 +66,7 @@ void S::operator_equals() { m_b4 = (i > 8); if (false == m_b4) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(!m_b4\) {$}} + // CHECK-FIXES: if (!m_b4) { i = 12; } else { i = 13; @@ -78,7 +78,7 @@ void S::operator_or() { m_b1 = (i > 10); if (m_b1 || false) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b1\) {$}} + // CHECK-FIXES: if (m_b1) { i = 14; } else { i = 15; @@ -86,7 +86,7 @@ void S::operator_or() { m_b2 = (i > 10); if (m_b2 || true) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(true\) {$}} + // CHECK-FIXES: if (true) { i = 16; } else { i = 17; @@ -94,7 +94,7 @@ void S::operator_or() { m_b3 = (i > 10); if (false || m_b3) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b3\) {$}} + // CHECK-FIXES: if (m_b3) { i = 18; } else { i = 19; @@ -102,7 +102,7 @@ void S::operator_or() { m_b4 = (i > 10); if (true || m_b4) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(true\) {$}} + // CHECK-FIXES: if (true) { i = 20; } else { i = 21; @@ -114,7 +114,7 @@ void S::operator_and() { m_b1 = (i > 20); if (m_b1 && false) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(false\) {$}} + // CHECK-FIXES: if (false) { i = 22; } else { i = 23; @@ -122,7 +122,7 @@ void S::operator_and() { m_b2 = (i > 20); if (m_b2 && true) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b2\) {$}} + // CHECK-FIXES: if (m_b2) { i = 24; } else { i = 25; @@ -130,7 +130,7 @@ void S::operator_and() { m_b3 = (i > 20); if (false && m_b3) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(false\) {$}} + // CHECK-FIXES: if (false) { i = 26; } else { i = 27; @@ -138,7 +138,7 @@ void S::operator_and() { m_b4 = (i > 20); if (true && m_b4) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b4\) {$}} + // CHECK-FIXES: if (m_b4) { i = 28; } else { i = 29; @@ -149,15 +149,15 @@ void S::ternary_operator() { int i = 0; m_b1 = (i > 20) ? true : false; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in ternary expression result - // CHECK-FIXES: {{^ m_b1 = i > 20;$}} + // CHECK-FIXES: m_b1 = i > 20; m_b2 = (i > 20) ? false : true; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in ternary expression result - // CHECK-FIXES: {{^ m_b2 = i <= 20;$}} + // CHECK-FIXES: m_b2 = i <= 20; m_b3 = ((i > 20)) ? false : true; // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: {{.*}} in ternary expression result - // CHECK-FIXES: {{^ m_b3 = i <= 20;$}} + // CHECK-FIXES: m_b3 = i <= 20; } void S::operator_not_equal() { @@ -165,7 +165,7 @@ void S::operator_not_equal() { m_b1 = (i > 20); if (false != m_b1) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b1\) {$}} + // CHECK-FIXES: if (m_b1) { i = 30; } else { i = 31; @@ -173,7 +173,7 @@ void S::operator_not_equal() { m_b2 = (i > 20); if (true != m_b2) { // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(!m_b2\) {$}} + // CHECK-FIXES: if (!m_b2) { i = 32; } else { i = 33; @@ -181,7 +181,7 @@ void S::operator_not_equal() { m_b3 = (i > 20); if (m_b3 != false) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(m_b3\) {$}} + // CHECK-FIXES: if (m_b3) { i = 34; } else { i = 35; @@ -189,7 +189,7 @@ void S::operator_not_equal() { m_b4 = (i > 20); if (m_b4 != true) { // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} to boolean operator - // CHECK-FIXES: {{^ if \(!m_b4\) {$}} + // CHECK-FIXES: if (!m_b4) { i = 36; } else { i = 37; @@ -203,7 +203,7 @@ void S::simple_conditional_assignment_statements() { m_b1 = false; bool bb = false; // CHECK-MESSAGES: :[[@LINE-4]]:12: warning: {{.*}} in conditional assignment - // CHECK-FIXES: {{^ }}m_b1 = m_i > 10;{{$}} + // CHECK-FIXES: m_b1 = m_i > 10; // CHECK-FIXES: bool bb = false; if (m_i > 20) @@ -212,7 +212,7 @@ void S::simple_conditional_assignment_statements() { m_b2 = true; bool c2 = false; // CHECK-MESSAGES: :[[@LINE-4]]:12: warning: {{.*}} in conditional assignment - // CHECK-FIXES: {{^ }}m_b2 = m_i <= 20;{{$}} + // CHECK-FIXES: m_b2 = m_i <= 20; // CHECK-FIXES: bool c2 = false; // Unchanged: different variables. @@ -249,7 +249,7 @@ void S::complex_conditional_assignment_statements() { } m_b1 = false; // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional assignment - // CHECK-FIXES: {{^ }}m_b1 = m_i > 30;{{$}} + // CHECK-FIXES: m_b1 = m_i > 30; // CHECK-FIXES: m_b1 = false; if (m_i > 40) { @@ -259,7 +259,7 @@ void S::complex_conditional_assignment_statements() { } m_b2 = false; // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional assignment - // CHECK-FIXES: {{^ }}m_b2 = m_i <= 40;{{$}} + // CHECK-FIXES: m_b2 = m_i <= 40; // CHECK-FIXES: m_b2 = false; } @@ -283,7 +283,7 @@ bool S::non_null_pointer_condition() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: return m_p != nullptr;{{$}} +// CHECK-FIXES: return m_p != nullptr; bool S::null_pointer_condition() { if (!m_p) { @@ -293,7 +293,7 @@ bool S::null_pointer_condition() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: return m_p == nullptr;{{$}} +// CHECK-FIXES: return m_p == nullptr; bool S::negated_non_null_pointer_condition() { if (m_p) { @@ -303,7 +303,7 @@ bool S::negated_non_null_pointer_condition() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: return m_p == nullptr;{{$}} +// CHECK-FIXES: return m_p == nullptr; bool S::negated_null_pointer_condition() { if (!m_p) { @@ -313,7 +313,7 @@ bool S::negated_null_pointer_condition() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: return m_p != nullptr;{{$}} +// CHECK-FIXES: return m_p != nullptr; bool S::integer_not_zero() { if (m_i) { @@ -323,7 +323,7 @@ bool S::integer_not_zero() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: {{^}} return m_i == 0;{{$}} +// CHECK-FIXES: return m_i == 0; bool S::member_pointer_nullptr() { if (m_m) { @@ -333,7 +333,7 @@ bool S::member_pointer_nullptr() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: return m_m != nullptr;{{$}} +// CHECK-FIXES: return m_m != nullptr; bool S::integer_member_implicit_cast() { if (m_a->m) { @@ -343,7 +343,7 @@ bool S::integer_member_implicit_cast() { } } // CHECK-MESSAGES: :[[@LINE-5]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: return m_a->m != 0;{{$}} +// CHECK-FIXES: return m_a->m != 0; bool operator!=(const A &, const A &) { return false; } bool S::expr_with_cleanups() { @@ -353,4 +353,4 @@ bool S::expr_with_cleanups() { return true; } // CHECK-MESSAGES: :[[@LINE-4]]:12: warning: {{.*}} in conditional return -// CHECK-FIXES: m_ar == (A)m_ar;{{$}} +// CHECK-FIXES: m_ar == (A)m_ar; diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance-nesting-threshold.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance-nesting-threshold.cpp index ee35e24..01b2e65 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance-nesting-threshold.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance-nesting-threshold.cpp @@ -19,15 +19,15 @@ void f(M::N::V::T::U u) { M::N::V v; v.v = 12; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} M::N::V::v = 12;{{$}} + // CHECK-FIXES: M::N::V::v = 12; M::N::V::T w; w.t = 12; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} M::N::V::T::t = 12;{{$}} + // CHECK-FIXES: M::N::V::T::t = 12; // u.u is not changed, because the nesting level is over 4 u.u = 12; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} u.u = 12;{{$}} + // CHECK-FIXES: u.u = 12; } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance.cpp index a0d51de..0db952c 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance.cpp @@ -48,7 +48,7 @@ void g() { f(1, 2, 3, 4).x; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member accessed through instance [readability-static-accessed-through-instance] // CHECK-MESSAGES: :[[@LINE-2]]:3: note: member base expression may carry some side effects - // CHECK-FIXES: {{^}} C::x;{{$}} + // CHECK-FIXES: C::x; } int i(int &); @@ -61,13 +61,13 @@ void f(C c) { j(i(h().x)); // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: static member // CHECK-MESSAGES: :[[@LINE-2]]:7: note: member base expression may carry some side effects - // CHECK-FIXES: {{^}} j(i(C::x));{{$}} + // CHECK-FIXES: j(i(C::x)); // The execution of h() depends on the return value of a(). j(k(a() && h().x)); // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: static member // CHECK-MESSAGES: :[[@LINE-2]]:14: note: member base expression may carry some side effects - // CHECK-FIXES: {{^}} j(k(a() && C::x));{{$}} + // CHECK-FIXES: j(k(a() && C::x)); if ([c]() { c.ns(); @@ -76,7 +76,7 @@ void f(C c) { ; // CHECK-MESSAGES: :[[@LINE-5]]:7: warning: static member // CHECK-MESSAGES: :[[@LINE-6]]:7: note: member base expression may carry some side effects - // CHECK-FIXES: {{^}} if (C::x == 15){{$}} + // CHECK-FIXES: if (C::x == 15) } // Nested specifiers @@ -96,23 +96,23 @@ void f(N::V::T::U u) { N::V v; v.v = 12; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} N::V::v = 12;{{$}} + // CHECK-FIXES: N::V::v = 12; N::V::T w; w.t = 12; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} N::V::T::t = 12;{{$}} + // CHECK-FIXES: N::V::T::t = 12; // u.u is not changed to N::V::T::U::u; because the nesting level is over 3. u.u = 12; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} u.u = 12;{{$}} + // CHECK-FIXES: u.u = 12; using B = N::V::T::U; B b; b.u; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} B::u;{{$}} + // CHECK-FIXES: B::u; } // Templates @@ -134,7 +134,7 @@ template <typename T> void f(T t, C c) { t.x; // OK, t is a template parameter. c.x; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::x;{{$}} + // CHECK-FIXES: C::x; } template <int N> struct S { static int x; }; @@ -148,33 +148,33 @@ template <int N> void h() { S<2> s2; s2.x; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} S<2>::x;{{$}} + // CHECK-FIXES: S<2>::x; } void static_through_instance() { C *c1 = new C(); c1->foo(); // 1 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::foo(); // 1{{$}} + // CHECK-FIXES: C::foo(); // 1 c1->x; // 2 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::x; // 2{{$}} + // CHECK-FIXES: C::x; // 2 c1->Anonymous; // 3 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::Anonymous; // 3{{$}} + // CHECK-FIXES: C::Anonymous; // 3 c1->E1; // 4 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::E1; // 4{{$}} + // CHECK-FIXES: C::E1; // 4 c1->E0; // 5 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::E0; // 5{{$}} + // CHECK-FIXES: C::E0; // 5 c1->nsx; // OK, nsx is a non-static member. const C *c2 = new C(); c2->foo(); // 2 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} C::foo(); // 2{{$}} + // CHECK-FIXES: C::foo(); // 2 C::foo(); // OK, foo() is accessed using a qualified-id. C::x; // OK, x is accessed using a qualified-id. @@ -182,18 +182,18 @@ void static_through_instance() { D d; d.foo(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} D::foo();{{$}} + // CHECK-FIXES: D::foo(); d.x; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} D::x;{{$}} + // CHECK-FIXES: D::x; E e; e.foo(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} E::foo();{{$}} + // CHECK-FIXES: E::foo(); e.x; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} E::x;{{$}} + // CHECK-FIXES: E::x; CC *cc = new CC; @@ -210,10 +210,10 @@ void static_through_instance() { CT<int> ct; ct.foo(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} CT<int>::foo();{{$}} + // CHECK-FIXES: CT<int>::foo(); ct.x; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} CT<int>::x;{{$}} + // CHECK-FIXES: CT<int>::x; ct.nsx; // OK, nsx is a non-static member CCT<int> cct; @@ -230,7 +230,7 @@ struct SP { void usep() { P.I; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} SP::I;{{$}} + // CHECK-FIXES: SP::I; } namespace NSP { @@ -242,7 +242,7 @@ struct SP { void usensp() { NSP::P.I; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} NSP::SP::I;{{$}} + // CHECK-FIXES: NSP::SP::I; } // Overloaded member access operator @@ -269,7 +269,7 @@ void func(Qptr qp) { qp->K = 10; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member accessed through instance [readability-static-accessed-through-instance] // CHECK-MESSAGES: :[[@LINE-2]]:3: note: member base expression may carry some side effects - // CHECK-FIXES: {{^}} Q::K = 10; + // CHECK-FIXES: Q::K = 10; } namespace { @@ -282,7 +282,7 @@ void use_anonymous() { Anonymous Anon; Anon.I; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} Anonymous::I;{{$}} + // CHECK-FIXES: Anonymous::I; } namespace Outer { @@ -297,7 +297,7 @@ void use_inline() { Outer::S V; V.I; // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member - // CHECK-FIXES: {{^}} Outer::S::I;{{$}} + // CHECK-FIXES: Outer::S::I; } // https://bugs.llvm.org/show_bug.cgi?id=48758 @@ -356,17 +356,17 @@ void testEmbeddedAnonymousStructAndClass() { Embedded E; E.EmbeddedStruct.f(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member accessed through instance [readability-static-accessed-through-instance] - // CHECK-FIXES: {{^}} llvm_issue_61736::Embedded::EmbeddedStruct.f();{{$}} + // CHECK-FIXES: llvm_issue_61736::Embedded::EmbeddedStruct.f(); E.EmbeddedStructPointer->f(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member accessed through instance [readability-static-accessed-through-instance] - // CHECK-FIXES: {{^}} llvm_issue_61736::Embedded::EmbeddedStructPointer->f();{{$}} + // CHECK-FIXES: llvm_issue_61736::Embedded::EmbeddedStructPointer->f(); E.EmbeddedClass.f(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member accessed through instance [readability-static-accessed-through-instance] - // CHECK-FIXES: {{^}} llvm_issue_61736::Embedded::EmbeddedClass.f();{{$}} + // CHECK-FIXES: llvm_issue_61736::Embedded::EmbeddedClass.f(); E.EmbeddedClassPointer->f(); // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member accessed through instance [readability-static-accessed-through-instance] - // CHECK-FIXES: {{^}} llvm_issue_61736::Embedded::EmbeddedClassPointer->f();{{$}} + // CHECK-FIXES: llvm_issue_61736::Embedded::EmbeddedClassPointer->f(); } } // namespace llvm_issue_61736 @@ -384,7 +384,7 @@ namespace PR51861 { auto& params = Foo::getInstance(); params.getBar(); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: static member accessed through instance [readability-static-accessed-through-instance] - // CHECK-FIXES: {{^}} PR51861::Foo::getBar();{{$}} + // CHECK-FIXES: PR51861::Foo::getBar(); } } @@ -401,6 +401,6 @@ namespace PR75163 { ptr->call(); // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: static member accessed through instance [readability-static-accessed-through-instance] // CHECK-MESSAGES: :[[@LINE-2]]:5: note: member base expression may carry some side effects - // CHECK-FIXES: {{^}} PR75163::Static::call();{{$}} + // CHECK-FIXES: PR75163::Static::call(); } } diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/static-definition-in-anonymous-namespace.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/static-definition-in-anonymous-namespace.cpp index e204199..eb10f72 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/static-definition-in-anonymous-namespace.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/static-definition-in-anonymous-namespace.cpp @@ -6,13 +6,13 @@ int a = 1; const int b = 1; static int c = 1; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 'c' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace] -// CHECK-FIXES: {{^}}int c = 1; +// CHECK-FIXES: int c = 1; static const int d = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: 'd' is a static definition in anonymous namespace -// CHECK-FIXES: {{^}}const int d = 1; +// CHECK-FIXES: const int d = 1; const static int e = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: 'e' is a static definition in anonymous namespace -// CHECK-FIXES: {{^}}const int e = 1; +// CHECK-FIXES: const int e = 1; void f() { int a = 1; @@ -21,40 +21,40 @@ void f() { static int g() { // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 'g' is a static definition in anonymous namespace -// CHECK-FIXES: {{^}}int g() { +// CHECK-FIXES: int g() { return 1; } #define DEFINE_STATIC static -// CHECK-FIXES: {{^}}#define DEFINE_STATIC static +// CHECK-FIXES: #define DEFINE_STATIC static DEFINE_STATIC int h = 1; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 'h' is a static definition in anonymous namespace -// CHECK-FIXES: {{^}}DEFINE_STATIC int h = 1; +// CHECK-FIXES: DEFINE_STATIC int h = 1; #define DEFINE_STATIC_VAR(x) static int x = 2 -// CHECK-FIXES: {{^}}#define DEFINE_STATIC_VAR(x) static int x = 2 +// CHECK-FIXES: #define DEFINE_STATIC_VAR(x) static int x = 2 DEFINE_STATIC_VAR(i); -// CHECK-FIXES: {{^}}DEFINE_STATIC_VAR(i); +// CHECK-FIXES: DEFINE_STATIC_VAR(i); namespace inner { int a = 1; const int b = 1; static int c = 1; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 'c' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace] -// CHECK-FIXES: {{^}}int c = 1; +// CHECK-FIXES: int c = 1; namespace deep_inner { int a = 1; const int b = 1; static int c = 1; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 'c' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace] -// CHECK-FIXES: {{^}}int c = 1; +// CHECK-FIXES: int c = 1; } // namespace deep_inner } // namespace inner template<typename T> static void printTemplate(T&&) {} // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 'printTemplate' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace] -// CHECK-FIXES: {{^}}void printTemplate(T&&) {} +// CHECK-FIXES: void printTemplate(T&&) {} void testTemplate() { printTemplate(5); diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/uniqueptr-delete-release.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/uniqueptr-delete-release.cpp index 6da0ad4..b469539 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/readability/uniqueptr-delete-release.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/uniqueptr-delete-release.cpp @@ -27,60 +27,60 @@ void Positives() { delete P.release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' to reset 'unique_ptr<>' objects // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' to reset 'unique_ptr<>' objects - // CHECK-FIXES-NULLPTR: {{^}} P = nullptr; - // CHECK-FIXES-RESET: {{^}} P.reset(); + // CHECK-FIXES-NULLPTR: P = nullptr; + // CHECK-FIXES-RESET: P.reset(); auto P2 = P; delete P2.release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' to reset 'unique_ptr<>' objects // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' to reset 'unique_ptr<>' objects - // CHECK-FIXES-NULLPTR: {{^}} P2 = nullptr; - // CHECK-FIXES-RESET: {{^}} P2.reset(); + // CHECK-FIXES-NULLPTR: P2 = nullptr; + // CHECK-FIXES-RESET: P2.reset(); delete (P2.release()); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} (P2 = nullptr); - // CHECK-FIXES-RESET: {{^}} (P2.reset()); + // CHECK-FIXES-NULLPTR: (P2 = nullptr); + // CHECK-FIXES-RESET: (P2.reset()); std::unique_ptr<int> Array[20]; delete Array[4].release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} Array[4] = nullptr; - // CHECK-FIXES-RESET: {{^}} Array[4].reset(); + // CHECK-FIXES-NULLPTR: Array[4] = nullptr; + // CHECK-FIXES-RESET: Array[4].reset(); delete ReturnsAUnique().release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} ReturnsAUnique() = nullptr; - // CHECK-FIXES-RESET: {{^}} ReturnsAUnique().reset(); + // CHECK-FIXES-NULLPTR: ReturnsAUnique() = nullptr; + // CHECK-FIXES-RESET: ReturnsAUnique().reset(); std::unique_ptr<int> *P3(&P); delete P3->release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} *P3 = nullptr; - // CHECK-FIXES-RESET: {{^}} P3->reset(); + // CHECK-FIXES-NULLPTR: *P3 = nullptr; + // CHECK-FIXES-RESET: P3->reset(); std::unique_ptr<std::unique_ptr<int>> P4; delete (*P4).release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} (*P4) = nullptr; - // CHECK-FIXES-RESET: {{^}} (*P4).reset(); + // CHECK-FIXES-NULLPTR: (*P4) = nullptr; + // CHECK-FIXES-RESET: (*P4).reset(); delete P4->release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} *P4 = nullptr; - // CHECK-FIXES-RESET: {{^}} P4->reset(); + // CHECK-FIXES-NULLPTR: *P4 = nullptr; + // CHECK-FIXES-RESET: P4->reset(); delete (P4)->release(); // CHECK-MESSAGES-NULLPTR: :[[@LINE-1]]:3: warning: prefer '= nullptr' // CHECK-MESSAGES-RESET: :[[@LINE-2]]:3: warning: prefer 'reset()' - // CHECK-FIXES-NULLPTR: {{^}} *(P4) = nullptr; - // CHECK-FIXES-RESET: {{^}} (P4)->reset(); + // CHECK-FIXES-NULLPTR: *(P4) = nullptr; + // CHECK-FIXES-RESET: (P4)->reset(); } struct NotDefaultDeleter {}; diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst index 12c2ada..5745e4b 100644 --- a/clang/docs/UsersManual.rst +++ b/clang/docs/UsersManual.rst @@ -2778,7 +2778,7 @@ usual build cycle when using sample profilers for optimization: > clang-cl /O2 -gdwarf -gline-tables-only ^ /clang:-fdebug-info-for-profiling /clang:-funique-internal-linkage-names ^ - code.cc /Fe:code /fuse-ld=lld /link /debug:dwarf + code.cc /Fe:code -fuse-ld=lld /link /debug:dwarf .. note:: @@ -2861,13 +2861,15 @@ usual build cycle when using sample profilers for optimization: that executes faster than the original one. Note that you are not required to build the code with the exact same arguments that you used in the first step. The only requirement is that you build the code - with the same debug info options and ``-fprofile-sample-use``. + with the same debug info options and ``-fprofile-sample-use``. ``-gdwarf`` + and ``-gline-tables-only`` can be omitted if you do not need debug info + in the final binary. On Linux: .. code-block:: console - $ clang++ -O2 -gline-tables-only \ + $ clang++ -O2 \ -fdebug-info-for-profiling -funique-internal-linkage-names \ -fprofile-sample-use=code.prof code.cc -o code @@ -2875,9 +2877,9 @@ usual build cycle when using sample profilers for optimization: .. code-block:: winbatch - > clang-cl /O2 -gdwarf -gline-tables-only ^ + > clang-cl /O2 ^ /clang:-fdebug-info-for-profiling /clang:-funique-internal-linkage-names ^ - -fprofile-sample-use=code.prof code.cc /Fe:code -fuse-ld=lld /link /debug:dwarf + -fprofile-sample-use=code.prof code.cc /Fe:code [OPTIONAL] Sampling-based profiles can have inaccuracies or missing block/ edge counters. The profile inference algorithm (profi) can be used to infer @@ -2886,7 +2888,7 @@ usual build cycle when using sample profilers for optimization: .. code-block:: console - $ clang++ -fsample-profile-use-profi -O2 -gline-tables-only \ + $ clang++ -fsample-profile-use-profi -O2 \ -fdebug-info-for-profiling -funique-internal-linkage-names \ -fprofile-sample-use=code.prof code.cc -o code @@ -2894,9 +2896,9 @@ usual build cycle when using sample profilers for optimization: .. code-block:: winbatch - > clang-cl /clang:-fsample-profile-use-profi /O2 -gdwarf -gline-tables-only ^ + > clang-cl /clang:-fsample-profile-use-profi /O2 ^ /clang:-fdebug-info-for-profiling /clang:-funique-internal-linkage-names ^ - -fprofile-sample-use=code.prof code.cc /Fe:code -fuse-ld=lld /link /debug:dwarf + -fprofile-sample-use=code.prof code.cc /Fe:code Sample Profile Formats """""""""""""""""""""" diff --git a/clang/docs/analyzer/developer-docs/Statistics.rst b/clang/docs/analyzer/developer-docs/Statistics.rst index 595b44d..4f2484a 100644 --- a/clang/docs/analyzer/developer-docs/Statistics.rst +++ b/clang/docs/analyzer/developer-docs/Statistics.rst @@ -22,7 +22,6 @@ However, note that with ``LLVM_ENABLE_STATS`` disabled, only storage of the valu If you want to define a statistic only for entry point, EntryPointStats.h has four classes at your disposal: -- ``BoolEPStat`` - a boolean value assigned at most once per entry point. For example: "has the inline limit been reached". - ``UnsignedEPStat`` - an unsigned value assigned at most once per entry point. For example: "the number of source characters in an entry-point body". - ``CounterEPStat`` - an additive statistic. It starts with 0 and you can add to it as many times as needed. For example: "the number of bugs discovered". - ``UnsignedMaxEPStat`` - a maximizing statistic. It starts with 0 and when you join it with a value, it picks the maximum of the previous value and the new one. For example, "the longest execution path of a bug". diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety.h deleted file mode 100644 index e54fc26..0000000 --- a/clang/include/clang/Analysis/Analyses/LifetimeSafety.h +++ /dev/null @@ -1,183 +0,0 @@ -//===- LifetimeSafety.h - C++ Lifetime Safety Analysis -*----------- C++-*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines the entry point for a dataflow-based static analysis -// that checks for C++ lifetime violations. -// -// The analysis is based on the concepts of "origins" and "loans" to track -// pointer lifetimes and detect issues like use-after-free and dangling -// pointers. See the RFC for more details: -// https://discourse.llvm.org/t/rfc-intra-procedural-lifetime-analysis-in-clang/86291 -// -//===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H -#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H -#include "clang/Analysis/AnalysisDeclContext.h" -#include "clang/Analysis/CFG.h" -#include "clang/Basic/SourceLocation.h" -#include "llvm/ADT/DenseMapInfo.h" -#include "llvm/ADT/ImmutableMap.h" -#include "llvm/ADT/ImmutableSet.h" -#include "llvm/ADT/StringMap.h" -#include <memory> - -namespace clang::lifetimes { - -/// Enum to track the confidence level of a potential error. -enum class Confidence : uint8_t { - None, - Maybe, // Reported as a potential error (-Wlifetime-safety-strict) - Definite // Reported as a definite error (-Wlifetime-safety-permissive) -}; - -enum class LivenessKind : uint8_t { - Dead, // Not alive - Maybe, // Live on some path but not all paths (may-be-live) - Must // Live on all paths (must-be-live) -}; - -class LifetimeSafetyReporter { -public: - LifetimeSafetyReporter() = default; - virtual ~LifetimeSafetyReporter() = default; - - virtual void reportUseAfterFree(const Expr *IssueExpr, const Expr *UseExpr, - SourceLocation FreeLoc, - Confidence Confidence) {} -}; - -/// The main entry point for the analysis. -void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC, - LifetimeSafetyReporter *Reporter); - -namespace internal { -// Forward declarations of internal types. -class Fact; -class FactManager; -class LoanPropagationAnalysis; -class ExpiredLoansAnalysis; -class LiveOriginAnalysis; -struct LifetimeFactory; - -/// A generic, type-safe wrapper for an ID, distinguished by its `Tag` type. -/// Used for giving ID to loans and origins. -template <typename Tag> struct ID { - uint32_t Value = 0; - - bool operator==(const ID<Tag> &Other) const { return Value == Other.Value; } - bool operator!=(const ID<Tag> &Other) const { return !(*this == Other); } - bool operator<(const ID<Tag> &Other) const { return Value < Other.Value; } - ID<Tag> operator++(int) { - ID<Tag> Tmp = *this; - ++Value; - return Tmp; - } - void Profile(llvm::FoldingSetNodeID &IDBuilder) const { - IDBuilder.AddInteger(Value); - } -}; - -using LoanID = ID<struct LoanTag>; -using OriginID = ID<struct OriginTag>; -inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, LoanID ID) { - return OS << ID.Value; -} -inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OriginID ID) { - return OS << ID.Value; -} - -// Using LLVM's immutable collections is efficient for dataflow analysis -// as it avoids deep copies during state transitions. -// TODO(opt): Consider using a bitset to represent the set of loans. -using LoanSet = llvm::ImmutableSet<LoanID>; -using OriginSet = llvm::ImmutableSet<OriginID>; -using OriginLoanMap = llvm::ImmutableMap<OriginID, LoanSet>; - -/// A `ProgramPoint` identifies a location in the CFG by pointing to a specific -/// `Fact`. identified by a lifetime-related event (`Fact`). -/// -/// A `ProgramPoint` has "after" semantics: it represents the location -/// immediately after its corresponding `Fact`. -using ProgramPoint = const Fact *; - -/// Running the lifetime safety analysis and querying its results. It -/// encapsulates the various dataflow analyses. -class LifetimeSafetyAnalysis { -public: - LifetimeSafetyAnalysis(AnalysisDeclContext &AC, - LifetimeSafetyReporter *Reporter); - ~LifetimeSafetyAnalysis(); - - void run(); - - /// Returns the set of loans an origin holds at a specific program point. - LoanSet getLoansAtPoint(OriginID OID, ProgramPoint PP) const; - - /// Returns the set of origins that are live at a specific program point, - /// along with the confidence level of their liveness. - /// - /// An origin is considered live if there are potential future uses of that - /// origin after the given program point. The confidence level indicates - /// whether the origin is definitely live (Definite) due to being domintated - /// by a set of uses or only possibly live (Maybe) only on some but not all - /// control flow paths. - std::vector<std::pair<OriginID, LivenessKind>> - getLiveOriginsAtPoint(ProgramPoint PP) const; - - /// Finds the OriginID for a given declaration. - /// Returns a null optional if not found. - std::optional<OriginID> getOriginIDForDecl(const ValueDecl *D) const; - - /// Finds the LoanID's for the loan created with the specific variable as - /// their Path. - std::vector<LoanID> getLoanIDForVar(const VarDecl *VD) const; - - /// Retrieves program points that were specially marked in the source code - /// for testing. - /// - /// The analysis recognizes special function calls of the form - /// `void("__lifetime_test_point_<name>")` as test points. This method returns - /// a map from the annotation string (<name>) to the corresponding - /// `ProgramPoint`. This allows test harnesses to query the analysis state at - /// user-defined locations in the code. - /// \note This is intended for testing only. - llvm::StringMap<ProgramPoint> getTestPoints() const; - -private: - AnalysisDeclContext &AC; - LifetimeSafetyReporter *Reporter; - std::unique_ptr<LifetimeFactory> Factory; - std::unique_ptr<FactManager> FactMgr; - std::unique_ptr<LoanPropagationAnalysis> LoanPropagation; - std::unique_ptr<LiveOriginAnalysis> LiveOrigins; -}; -} // namespace internal -} // namespace clang::lifetimes - -namespace llvm { -template <typename Tag> -struct DenseMapInfo<clang::lifetimes::internal::ID<Tag>> { - using ID = clang::lifetimes::internal::ID<Tag>; - - static inline ID getEmptyKey() { - return {DenseMapInfo<uint32_t>::getEmptyKey()}; - } - - static inline ID getTombstoneKey() { - return {DenseMapInfo<uint32_t>::getTombstoneKey()}; - } - - static unsigned getHashValue(const ID &Val) { - return DenseMapInfo<uint32_t>::getHashValue(Val.Value); - } - - static bool isEqual(const ID &LHS, const ID &RHS) { return LHS == RHS; } -}; -} // namespace llvm - -#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/Checker.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Checker.h new file mode 100644 index 0000000..03636be --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Checker.h @@ -0,0 +1,35 @@ +//===- Checker.h - C++ Lifetime Safety Analysis -*----------- C++-*-=========// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines and enforces the lifetime safety policy. It detects +// use-after-free errors by examining loan expiration points and checking if +// any live origins hold the expired loans. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_CHECKER_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_CHECKER_H + +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h" + +namespace clang::lifetimes::internal { + +/// Runs the lifetime checker, which detects use-after-free errors by +/// examining loan expiration points and checking if any live origins hold +/// the expired loan. +void runLifetimeChecker(const LoanPropagationAnalysis &LoanPropagation, + const LiveOriginsAnalysis &LiveOrigins, + const FactManager &FactMgr, AnalysisDeclContext &ADC, + LifetimeSafetyReporter *Reporter); + +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_CHECKER_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/Facts.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Facts.h new file mode 100644 index 0000000..6a90aeb --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Facts.h @@ -0,0 +1,232 @@ +//===- Facts.h - Lifetime Analysis Facts and Fact Manager ------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines Facts, which are atomic lifetime-relevant events (such as +// loan issuance, loan expiration, origin flow, and use), and the FactManager, +// which manages the storage and retrieval of facts for each CFG block. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_FACTS_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_FACTS_H + +#include "clang/Analysis/Analyses/LifetimeSafety/Loans.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Origins.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/Debug.h" +#include <cstdint> + +namespace clang::lifetimes::internal { +/// An abstract base class for a single, atomic lifetime-relevant event. +class Fact { + +public: + enum class Kind : uint8_t { + /// A new loan is issued from a borrow expression (e.g., &x). + Issue, + /// A loan expires as its underlying storage is freed (e.g., variable goes + /// out of scope). + Expire, + /// An origin is propagated from a source to a destination (e.g., p = q). + /// This can also optionally kill the destination origin before flowing into + /// it. Otherwise, the source's loan set is merged into the destination's + /// loan set. + OriginFlow, + /// An origin escapes the function by flowing into the return value. + ReturnOfOrigin, + /// An origin is used (eg. appears as l-value expression like DeclRefExpr). + Use, + /// A marker for a specific point in the code, for testing. + TestPoint, + }; + +private: + Kind K; + +protected: + Fact(Kind K) : K(K) {} + +public: + virtual ~Fact() = default; + Kind getKind() const { return K; } + + template <typename T> const T *getAs() const { + if (T::classof(this)) + return static_cast<const T *>(this); + return nullptr; + } + + virtual void dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &) const; +}; + +/// A `ProgramPoint` identifies a location in the CFG by pointing to a specific +/// `Fact`. identified by a lifetime-related event (`Fact`). +/// +/// A `ProgramPoint` has "after" semantics: it represents the location +/// immediately after its corresponding `Fact`. +using ProgramPoint = const Fact *; + +class IssueFact : public Fact { + LoanID LID; + OriginID OID; + +public: + static bool classof(const Fact *F) { return F->getKind() == Kind::Issue; } + + IssueFact(LoanID LID, OriginID OID) : Fact(Kind::Issue), LID(LID), OID(OID) {} + LoanID getLoanID() const { return LID; } + OriginID getOriginID() const { return OID; } + void dump(llvm::raw_ostream &OS, const LoanManager &LM, + const OriginManager &OM) const override; +}; + +class ExpireFact : public Fact { + LoanID LID; + SourceLocation ExpiryLoc; + +public: + static bool classof(const Fact *F) { return F->getKind() == Kind::Expire; } + + ExpireFact(LoanID LID, SourceLocation ExpiryLoc) + : Fact(Kind::Expire), LID(LID), ExpiryLoc(ExpiryLoc) {} + + LoanID getLoanID() const { return LID; } + SourceLocation getExpiryLoc() const { return ExpiryLoc; } + + void dump(llvm::raw_ostream &OS, const LoanManager &LM, + const OriginManager &) const override; +}; + +class OriginFlowFact : public Fact { + OriginID OIDDest; + OriginID OIDSrc; + // True if the destination origin should be killed (i.e., its current loans + // cleared) before the source origin's loans are flowed into it. + bool KillDest; + +public: + static bool classof(const Fact *F) { + return F->getKind() == Kind::OriginFlow; + } + + OriginFlowFact(OriginID OIDDest, OriginID OIDSrc, bool KillDest) + : Fact(Kind::OriginFlow), OIDDest(OIDDest), OIDSrc(OIDSrc), + KillDest(KillDest) {} + + OriginID getDestOriginID() const { return OIDDest; } + OriginID getSrcOriginID() const { return OIDSrc; } + bool getKillDest() const { return KillDest; } + + void dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &OM) const override; +}; + +class ReturnOfOriginFact : public Fact { + OriginID OID; + +public: + static bool classof(const Fact *F) { + return F->getKind() == Kind::ReturnOfOrigin; + } + + ReturnOfOriginFact(OriginID OID) : Fact(Kind::ReturnOfOrigin), OID(OID) {} + OriginID getReturnedOriginID() const { return OID; } + void dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &OM) const override; +}; + +class UseFact : public Fact { + const Expr *UseExpr; + // True if this use is a write operation (e.g., left-hand side of assignment). + // Write operations are exempted from use-after-free checks. + bool IsWritten = false; + +public: + static bool classof(const Fact *F) { return F->getKind() == Kind::Use; } + + UseFact(const Expr *UseExpr) : Fact(Kind::Use), UseExpr(UseExpr) {} + + OriginID getUsedOrigin(const OriginManager &OM) const { + // TODO: Remove const cast and make OriginManager::get as const. + return const_cast<OriginManager &>(OM).get(*UseExpr); + } + const Expr *getUseExpr() const { return UseExpr; } + void markAsWritten() { IsWritten = true; } + bool isWritten() const { return IsWritten; } + + void dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &OM) const override; +}; + +/// A dummy-fact used to mark a specific point in the code for testing. +/// It is generated by recognizing a `void("__lifetime_test_point_...")` cast. +class TestPointFact : public Fact { + StringRef Annotation; + +public: + static bool classof(const Fact *F) { return F->getKind() == Kind::TestPoint; } + + explicit TestPointFact(StringRef Annotation) + : Fact(Kind::TestPoint), Annotation(Annotation) {} + + StringRef getAnnotation() const { return Annotation; } + + void dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &) const override; +}; + +class FactManager { +public: + llvm::ArrayRef<const Fact *> getFacts(const CFGBlock *B) const { + auto It = BlockToFactsMap.find(B); + if (It != BlockToFactsMap.end()) + return It->second; + return {}; + } + + void addBlockFacts(const CFGBlock *B, llvm::ArrayRef<Fact *> NewFacts) { + if (!NewFacts.empty()) + BlockToFactsMap[B].assign(NewFacts.begin(), NewFacts.end()); + } + + template <typename FactType, typename... Args> + FactType *createFact(Args &&...args) { + void *Mem = FactAllocator.Allocate<FactType>(); + return new (Mem) FactType(std::forward<Args>(args)...); + } + + void dump(const CFG &Cfg, AnalysisDeclContext &AC) const; + + /// Retrieves program points that were specially marked in the source code + /// for testing. + /// + /// The analysis recognizes special function calls of the form + /// `void("__lifetime_test_point_<name>")` as test points. This method returns + /// a map from the annotation string (<name>) to the corresponding + /// `ProgramPoint`. This allows test harnesses to query the analysis state at + /// user-defined locations in the code. + /// \note This is intended for testing only. + llvm::StringMap<ProgramPoint> getTestPoints() const; + + LoanManager &getLoanMgr() { return LoanMgr; } + const LoanManager &getLoanMgr() const { return LoanMgr; } + OriginManager &getOriginMgr() { return OriginMgr; } + const OriginManager &getOriginMgr() const { return OriginMgr; } + +private: + LoanManager LoanMgr; + OriginManager OriginMgr; + llvm::DenseMap<const clang::CFGBlock *, llvm::SmallVector<const Fact *>> + BlockToFactsMap; + llvm::BumpPtrAllocator FactAllocator; +}; +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_FACTS_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/FactsGenerator.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/FactsGenerator.h new file mode 100644 index 0000000..5e58abe --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/FactsGenerator.h @@ -0,0 +1,106 @@ +//===- FactsGenerator.h - Lifetime Facts Generation -------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the FactsGenerator, which traverses the AST to generate +// lifetime-relevant facts (such as loan issuance, expiration, origin flow, +// and use) from CFG statements. These facts are used by the dataflow analyses +// to track pointer lifetimes and detect use-after-free errors. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_FACTSGENERATOR_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_FACTSGENERATOR_H + +#include "clang/AST/StmtVisitor.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Origins.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "llvm/ADT/SmallVector.h" + +namespace clang::lifetimes::internal { + +class FactsGenerator : public ConstStmtVisitor<FactsGenerator> { + using Base = ConstStmtVisitor<FactsGenerator>; + +public: + FactsGenerator(FactManager &FactMgr, AnalysisDeclContext &AC) + : FactMgr(FactMgr), AC(AC) {} + + void run(); + + void VisitDeclStmt(const DeclStmt *DS); + void VisitDeclRefExpr(const DeclRefExpr *DRE); + void VisitCXXConstructExpr(const CXXConstructExpr *CCE); + void VisitCXXMemberCallExpr(const CXXMemberCallExpr *MCE); + void VisitCallExpr(const CallExpr *CE); + void VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *N); + void VisitImplicitCastExpr(const ImplicitCastExpr *ICE); + void VisitUnaryOperator(const UnaryOperator *UO); + void VisitReturnStmt(const ReturnStmt *RS); + void VisitBinaryOperator(const BinaryOperator *BO); + void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *OCE); + void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *FCE); + void VisitInitListExpr(const InitListExpr *ILE); + void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *MTE); + +private: + void handleDestructor(const CFGAutomaticObjDtor &DtorOpt); + + void handleGSLPointerConstruction(const CXXConstructExpr *CCE); + + /// Checks if a call-like expression creates a borrow by passing a value to a + /// reference parameter, creating an IssueFact if it does. + /// \param IsGslConstruction True if this is a GSL construction where all + /// argument origins should flow to the returned origin. + void handleFunctionCall(const Expr *Call, const FunctionDecl *FD, + ArrayRef<const Expr *> Args, + bool IsGslConstruction = false); + + template <typename Destination, typename Source> + void flowOrigin(const Destination &D, const Source &S) { + OriginID DestOID = FactMgr.getOriginMgr().getOrCreate(D); + OriginID SrcOID = FactMgr.getOriginMgr().get(S); + CurrentBlockFacts.push_back(FactMgr.createFact<OriginFlowFact>( + DestOID, SrcOID, /*KillDest=*/false)); + } + + template <typename Destination, typename Source> + void killAndFlowOrigin(const Destination &D, const Source &S) { + OriginID DestOID = FactMgr.getOriginMgr().getOrCreate(D); + OriginID SrcOID = FactMgr.getOriginMgr().get(S); + CurrentBlockFacts.push_back( + FactMgr.createFact<OriginFlowFact>(DestOID, SrcOID, /*KillDest=*/true)); + } + + /// Checks if the expression is a `void("__lifetime_test_point_...")` cast. + /// If so, creates a `TestPointFact` and returns true. + bool handleTestPoint(const CXXFunctionalCastExpr *FCE); + + void handleAssignment(const Expr *LHSExpr, const Expr *RHSExpr); + + // A DeclRefExpr will be treated as a use of the referenced decl. It will be + // checked for use-after-free unless it is later marked as being written to + // (e.g. on the left-hand side of an assignment). + void handleUse(const DeclRefExpr *DRE); + + void markUseAsWrite(const DeclRefExpr *DRE); + + FactManager &FactMgr; + AnalysisDeclContext &AC; + llvm::SmallVector<Fact *> CurrentBlockFacts; + // To distinguish between reads and writes for use-after-free checks, this map + // stores the `UseFact` for each `DeclRefExpr`. We initially identify all + // `DeclRefExpr`s as "read" uses. When an assignment is processed, the use + // corresponding to the left-hand side is updated to be a "write", thereby + // exempting it from the check. + llvm::DenseMap<const DeclRefExpr *, UseFact *> UseFacts; +}; + +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_FACTSGENERATOR_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeAnnotations.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h index 229d16c..f02969e 100644 --- a/clang/include/clang/Analysis/Analyses/LifetimeAnnotations.h +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h @@ -12,8 +12,7 @@ #include "clang/AST/DeclCXX.h" -namespace clang { -namespace lifetimes { +namespace clang ::lifetimes { /// Returns the most recent declaration of the method to ensure all /// lifetime-bound attributes from redeclarations are considered. @@ -38,7 +37,7 @@ bool isAssignmentOperatorLifetimeBound(const CXXMethodDecl *CMD); /// lifetimebound, either due to an explicit lifetimebound attribute on the /// method or because it's a normal assignment operator. bool implicitObjectParamIsLifetimeBound(const FunctionDecl *FD); -} // namespace lifetimes -} // namespace clang + +} // namespace clang::lifetimes #endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMEANNOTATIONS_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h new file mode 100644 index 0000000..91ffbb1 --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h @@ -0,0 +1,87 @@ +//===- LifetimeSafety.h - C++ Lifetime Safety Analysis -*----------- C++-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the main entry point and orchestrator for the C++ Lifetime +// Safety Analysis. It coordinates the entire analysis pipeline: fact +// generation, loan propagation, live origins analysis, and enforcement of +// lifetime safety policy. +// +// The analysis is based on the concepts of "origins" and "loans" to track +// pointer lifetimes and detect issues like use-after-free and dangling +// pointers. See the RFC for more details: +// https://discourse.llvm.org/t/rfc-intra-procedural-lifetime-analysis-in-clang/86291 +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H + +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h" +#include "clang/Analysis/AnalysisDeclContext.h" + +namespace clang::lifetimes { + +/// Enum to track the confidence level of a potential error. +enum class Confidence : uint8_t { + None, + Maybe, // Reported as a potential error (-Wlifetime-safety-strict) + Definite // Reported as a definite error (-Wlifetime-safety-permissive) +}; + +class LifetimeSafetyReporter { +public: + LifetimeSafetyReporter() = default; + virtual ~LifetimeSafetyReporter() = default; + + virtual void reportUseAfterFree(const Expr *IssueExpr, const Expr *UseExpr, + SourceLocation FreeLoc, + Confidence Confidence) {} +}; + +/// The main entry point for the analysis. +void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC, + LifetimeSafetyReporter *Reporter); + +namespace internal { +/// An object to hold the factories for immutable collections, ensuring +/// that all created states share the same underlying memory management. +struct LifetimeFactory { + OriginLoanMap::Factory OriginMapFactory{/*canonicalize=*/false}; + LoanSet::Factory LoanSetFactory{/*canonicalize=*/false}; + LivenessMap::Factory LivenessMapFactory{/*canonicalize=*/false}; +}; + +/// Running the lifetime safety analysis and querying its results. It +/// encapsulates the various dataflow analyses. +class LifetimeSafetyAnalysis { +public: + LifetimeSafetyAnalysis(AnalysisDeclContext &AC, + LifetimeSafetyReporter *Reporter); + + void run(); + + /// \note These are provided only for testing purposes. + LoanPropagationAnalysis &getLoanPropagation() const { + return *LoanPropagation; + } + LiveOriginsAnalysis &getLiveOrigins() const { return *LiveOrigins; } + FactManager &getFactManager() { return FactMgr; } + +private: + AnalysisDeclContext &AC; + LifetimeSafetyReporter *Reporter; + LifetimeFactory Factory; + FactManager FactMgr; + std::unique_ptr<LiveOriginsAnalysis> LiveOrigins; + std::unique_ptr<LoanPropagationAnalysis> LoanPropagation; +}; +} // namespace internal +} // namespace clang::lifetimes + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h new file mode 100644 index 0000000..c4f5f0e --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h @@ -0,0 +1,97 @@ +//===- LiveOrigins.h - Live Origins Analysis -------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the LiveOriginAnalysis, a backward dataflow analysis that +// determines which origins are "live" at each program point. An origin is +// "live" at a program point if there's a potential future use of a pointer it +// is associated with. Liveness is "generated" by a use of an origin (e.g., a +// `UseFact` from a read of a pointer) and is "killed" (i.e., it stops being +// live) when the origin is replaced by flowing a different origin into it +// (e.g., an OriginFlow from an assignment that kills the destination). +// +// This information is used for detecting use-after-free errors, as it allows us +// to check if a live origin holds a loan to an object that has already expired. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIVE_ORIGINS_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIVE_ORIGINS_H + +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Origins.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/ImmutableMap.h" +#include "llvm/Support/Debug.h" + +namespace clang::lifetimes::internal { + +enum class LivenessKind : uint8_t { + Dead, // Not alive + Maybe, // Live on some path but not all paths (may-be-live) + Must // Live on all paths (must-be-live) +}; + +/// Information about why an origin is live at a program point. +struct LivenessInfo { + /// The use that makes the origin live. If liveness is propagated from + /// multiple uses along different paths, this will point to the use appearing + /// earlier in the translation unit. + /// This is 'null' when the origin is not live. + const UseFact *CausingUseFact; + + /// The kind of liveness of the origin. + /// `Must`: The origin is live on all control-flow paths from the current + /// point to the function's exit (i.e. the current point is dominated by a set + /// of uses). + /// `Maybe`: indicates it is live on some but not all paths. + /// + /// This determines the diagnostic's confidence level. + /// `Must`-be-alive at expiration implies a definite use-after-free, + /// while `Maybe`-be-alive suggests a potential one on some paths. + LivenessKind Kind; + + LivenessInfo() : CausingUseFact(nullptr), Kind(LivenessKind::Dead) {} + LivenessInfo(const UseFact *UF, LivenessKind K) + : CausingUseFact(UF), Kind(K) {} + + bool operator==(const LivenessInfo &Other) const { + return CausingUseFact == Other.CausingUseFact && Kind == Other.Kind; + } + bool operator!=(const LivenessInfo &Other) const { return !(*this == Other); } + + void Profile(llvm::FoldingSetNodeID &IDBuilder) const { + IDBuilder.AddPointer(CausingUseFact); + IDBuilder.Add(Kind); + } +}; + +using LivenessMap = llvm::ImmutableMap<OriginID, LivenessInfo>; + +class LiveOriginsAnalysis { +public: + LiveOriginsAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F, + LivenessMap::Factory &SF); + ~LiveOriginsAnalysis(); + + /// Returns the set of origins that are live at a specific program point, + /// along with the the details of the liveness. + LivenessMap getLiveOriginsAt(ProgramPoint P) const; + + // Dump liveness values on all test points in the program. + void dump(llvm::raw_ostream &OS, + llvm::StringMap<ProgramPoint> TestPoints) const; + +private: + class Impl; + std::unique_ptr<Impl> PImpl; +}; + +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIVE_ORIGINS_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h new file mode 100644 index 0000000..447d05c --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h @@ -0,0 +1,48 @@ +//===- LoanPropagation.h - Loan Propagation Analysis -----------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the LoanPropagationAnalysis, a forward dataflow analysis +// that tracks which loans each origin holds at each program point. Loans +// represent borrows of storage locations and are propagated through the +// program as pointers are copied or assigned. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOAN_PROPAGATION_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOAN_PROPAGATION_H + +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "llvm/ADT/ImmutableMap.h" +#include "llvm/ADT/ImmutableSet.h" + +namespace clang::lifetimes::internal { + +// Using LLVM's immutable collections is efficient for dataflow analysis +// as it avoids deep copies during state transitions. +// TODO(opt): Consider using a bitset to represent the set of loans. +using LoanSet = llvm::ImmutableSet<LoanID>; +using OriginLoanMap = llvm::ImmutableMap<OriginID, LoanSet>; + +class LoanPropagationAnalysis { +public: + LoanPropagationAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F, + OriginLoanMap::Factory &OriginLoanMapFactory, + LoanSet::Factory &LoanSetFactory); + ~LoanPropagationAnalysis(); + + LoanSet getLoans(OriginID OID, ProgramPoint P) const; + +private: + class Impl; + std::unique_ptr<Impl> PImpl; +}; + +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOAN_PROPAGATION_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/Loans.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Loans.h new file mode 100644 index 0000000..7f5cf03 --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Loans.h @@ -0,0 +1,80 @@ +//===- Loans.h - Loan and Access Path Definitions --------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the Loan and AccessPath structures, which represent +// borrows of storage locations, and the LoanManager, which manages the +// creation and retrieval of loans during lifetime analysis. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOANS_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOANS_H + +#include "clang/AST/Decl.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Utils.h" +#include "llvm/Support/raw_ostream.h" + +namespace clang::lifetimes::internal { + +using LoanID = utils::ID<struct LoanTag>; +inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, LoanID ID) { + return OS << ID.Value; +} + +/// Represents the storage location being borrowed, e.g., a specific stack +/// variable. +/// TODO: Model access paths of other types, e.g., s.field, heap and globals. +struct AccessPath { + const clang::ValueDecl *D; + + AccessPath(const clang::ValueDecl *D) : D(D) {} +}; + +/// Information about a single borrow, or "Loan". A loan is created when a +/// reference or pointer is created. +struct Loan { + /// TODO: Represent opaque loans. + /// TODO: Represent nullptr: loans to no path. Accessing it UB! Currently it + /// is represented as empty LoanSet + LoanID ID; + AccessPath Path; + /// The expression that creates the loan, e.g., &x. + const Expr *IssueExpr; + + Loan(LoanID id, AccessPath path, const Expr *IssueExpr) + : ID(id), Path(path), IssueExpr(IssueExpr) {} + + void dump(llvm::raw_ostream &OS) const; +}; + +/// Manages the creation, storage and retrieval of loans. +class LoanManager { +public: + LoanManager() = default; + + Loan &addLoan(AccessPath Path, const Expr *IssueExpr) { + AllLoans.emplace_back(getNextLoanID(), Path, IssueExpr); + return AllLoans.back(); + } + + const Loan &getLoan(LoanID ID) const { + assert(ID.Value < AllLoans.size()); + return AllLoans[ID.Value]; + } + llvm::ArrayRef<Loan> getLoans() const { return AllLoans; } + +private: + LoanID getNextLoanID() { return NextLoanID++; } + + LoanID NextLoanID{0}; + /// TODO(opt): Profile and evaluate the usefullness of small buffer + /// optimisation. + llvm::SmallVector<Loan> AllLoans; +}; +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOANS_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/Origins.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Origins.h new file mode 100644 index 0000000..ba138b0 --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Origins.h @@ -0,0 +1,91 @@ +//===- Origins.h - Origin and Origin Management ----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines Origins, which represent the set of possible loans a +// pointer-like object could hold, and the OriginManager, which manages the +// creation, storage, and retrieval of origins for variables and expressions. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_ORIGINS_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_ORIGINS_H + +#include "clang/AST/Decl.h" +#include "clang/AST/Expr.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Utils.h" + +namespace clang::lifetimes::internal { + +using OriginID = utils::ID<struct OriginTag>; + +inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OriginID ID) { + return OS << ID.Value; +} + +/// An Origin is a symbolic identifier that represents the set of possible +/// loans a pointer-like object could hold at any given time. +/// TODO: Enhance the origin model to handle complex types, pointer +/// indirection and reborrowing. The plan is to move from a single origin per +/// variable/expression to a "list of origins" governed by the Type. +/// For example, the type 'int**' would have two origins. +/// See discussion: +/// https://github.com/llvm/llvm-project/pull/142313/commits/0cd187b01e61b200d92ca0b640789c1586075142#r2137644238 +struct Origin { + OriginID ID; + /// A pointer to the AST node that this origin represents. This union + /// distinguishes between origins from declarations (variables or parameters) + /// and origins from expressions. + llvm::PointerUnion<const clang::ValueDecl *, const clang::Expr *> Ptr; + + Origin(OriginID ID, const clang::ValueDecl *D) : ID(ID), Ptr(D) {} + Origin(OriginID ID, const clang::Expr *E) : ID(ID), Ptr(E) {} + + const clang::ValueDecl *getDecl() const { + return Ptr.dyn_cast<const clang::ValueDecl *>(); + } + const clang::Expr *getExpr() const { + return Ptr.dyn_cast<const clang::Expr *>(); + } +}; + +/// Manages the creation, storage, and retrieval of origins for pointer-like +/// variables and expressions. +class OriginManager { +public: + OriginManager() = default; + + Origin &addOrigin(OriginID ID, const clang::ValueDecl &D); + Origin &addOrigin(OriginID ID, const clang::Expr &E); + + // TODO: Mark this method as const once we remove the call to getOrCreate. + OriginID get(const Expr &E); + + OriginID get(const ValueDecl &D); + + OriginID getOrCreate(const Expr &E); + + const Origin &getOrigin(OriginID ID) const; + + llvm::ArrayRef<Origin> getOrigins() const { return AllOrigins; } + + OriginID getOrCreate(const ValueDecl &D); + + void dump(OriginID OID, llvm::raw_ostream &OS) const; + +private: + OriginID getNextOriginID() { return NextOriginID++; } + + OriginID NextOriginID{0}; + /// TODO(opt): Profile and evaluate the usefullness of small buffer + /// optimisation. + llvm::SmallVector<Origin> AllOrigins; + llvm::DenseMap<const clang::ValueDecl *, OriginID> DeclToOriginID; + llvm::DenseMap<const clang::Expr *, OriginID> ExprToOriginID; +}; +} // namespace clang::lifetimes::internal + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_ORIGINS_H diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/Utils.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Utils.h new file mode 100644 index 0000000..4183cab --- /dev/null +++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/Utils.h @@ -0,0 +1,118 @@ +//===- Utils.h - Utility Functions for Lifetime Safety --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// This file provides utilities for the lifetime safety analysis, including +// join operations for LLVM's immutable data structures. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_UTILS_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_UTILS_H + +#include "llvm/ADT/ImmutableMap.h" +#include "llvm/ADT/ImmutableSet.h" + +namespace clang::lifetimes::internal::utils { + +/// A generic, type-safe wrapper for an ID, distinguished by its `Tag` type. +/// Used for giving ID to loans and origins. +template <typename Tag> struct ID { + uint32_t Value = 0; + + bool operator==(const ID<Tag> &Other) const { return Value == Other.Value; } + bool operator!=(const ID<Tag> &Other) const { return !(*this == Other); } + bool operator<(const ID<Tag> &Other) const { return Value < Other.Value; } + ID<Tag> operator++(int) { + ID<Tag> Tmp = *this; + ++Value; + return Tmp; + } + void Profile(llvm::FoldingSetNodeID &IDBuilder) const { + IDBuilder.AddInteger(Value); + } +}; + +/// Computes the union of two ImmutableSets. +template <typename T> +static llvm::ImmutableSet<T> join(llvm::ImmutableSet<T> A, + llvm::ImmutableSet<T> B, + typename llvm::ImmutableSet<T>::Factory &F) { + if (A.getHeight() < B.getHeight()) + std::swap(A, B); + for (const T &E : B) + A = F.add(A, E); + return A; +} + +/// Describes the strategy for joining two `ImmutableMap` instances, primarily +/// differing in how they handle keys that are unique to one of the maps. +/// +/// A `Symmetric` join is universally correct, while an `Asymmetric` join +/// serves as a performance optimization. The latter is applicable only when the +/// join operation possesses a left identity element, allowing for a more +/// efficient, one-sided merge. +enum class JoinKind { + /// A symmetric join applies the `JoinValues` operation to keys unique to + /// either map, ensuring that values from both maps contribute to the result. + Symmetric, + /// An asymmetric join preserves keys unique to the first map as-is, while + /// applying the `JoinValues` operation only to keys unique to the second map. + Asymmetric, +}; + +/// Computes the key-wise union of two ImmutableMaps. +// TODO(opt): This key-wise join is a performance bottleneck. A more +// efficient merge could be implemented using a Patricia Trie or HAMT +// instead of the current AVL-tree-based ImmutableMap. +template <typename K, typename V, typename Joiner> +static llvm::ImmutableMap<K, V> +join(const llvm::ImmutableMap<K, V> &A, const llvm::ImmutableMap<K, V> &B, + typename llvm::ImmutableMap<K, V>::Factory &F, Joiner JoinValues, + JoinKind Kind) { + if (A.getHeight() < B.getHeight()) + return join(B, A, F, JoinValues, Kind); + + // For each element in B, join it with the corresponding element in A + // (or with an empty value if it doesn't exist in A). + llvm::ImmutableMap<K, V> Res = A; + for (const auto &Entry : B) { + const K &Key = Entry.first; + const V &ValB = Entry.second; + Res = F.add(Res, Key, JoinValues(A.lookup(Key), &ValB)); + } + if (Kind == JoinKind::Symmetric) { + for (const auto &Entry : A) { + const K &Key = Entry.first; + const V &ValA = Entry.second; + if (!B.contains(Key)) + Res = F.add(Res, Key, JoinValues(&ValA, nullptr)); + } + } + return Res; +} +} // namespace clang::lifetimes::internal::utils + +namespace llvm { +template <typename Tag> +struct DenseMapInfo<clang::lifetimes::internal::utils::ID<Tag>> { + using ID = clang::lifetimes::internal::utils::ID<Tag>; + + static inline ID getEmptyKey() { + return {DenseMapInfo<uint32_t>::getEmptyKey()}; + } + + static inline ID getTombstoneKey() { + return {DenseMapInfo<uint32_t>::getTombstoneKey()}; + } + + static unsigned getHashValue(const ID &Val) { + return DenseMapInfo<uint32_t>::getHashValue(Val.Value); + } + + static bool isEqual(const ID &LHS, const ID &RHS) { return LHS == RHS; } +}; +} // namespace llvm + +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_UTILS_H diff --git a/clang/include/clang/Basic/BuiltinsAMDGPU.def b/clang/include/clang/Basic/BuiltinsAMDGPU.def index 3e45c04..8428fa9 100644 --- a/clang/include/clang/Basic/BuiltinsAMDGPU.def +++ b/clang/include/clang/Basic/BuiltinsAMDGPU.def @@ -885,5 +885,79 @@ TARGET_BUILTIN(__builtin_amdgcn_cooperative_atomic_store_16x8B, "vV2i*V2iIicC*", TARGET_BUILTIN(__builtin_amdgcn_cooperative_atomic_load_8x16B, "V4iV4i*IicC*", "nc", "gfx1250-insts,wavefrontsize32") TARGET_BUILTIN(__builtin_amdgcn_cooperative_atomic_store_8x16B, "vV4i*V4iIicC*", "nc", "gfx1250-insts,wavefrontsize32") +//===----------------------------------------------------------------------===// +// Image builtins +//===----------------------------------------------------------------------===// +TARGET_BUILTIN(__builtin_amdgcn_image_load_1d_v4f32_i32, "V4fiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_1d_v4f16_i32, "V4hiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_1darray_v4f32_i32, "V4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_1darray_v4f16_i32, "V4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2d_f32_i32, "fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2d_v4f32_i32, "V4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2d_v4f16_i32, "V4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2darray_f32_i32, "fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2darray_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2darray_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_3d_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_3d_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_cube_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_cube_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1d_v4f32_i32, "V4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1d_v4f16_i32, "V4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1darray_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1darray_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2d_f32_i32, "fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2d_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2d_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2darray_f32_i32, "fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2darray_v4f32_i32, "V4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2darray_v4f16_i32, "V4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_3d_v4f32_i32, "V4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_3d_v4f16_i32, "V4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_cube_v4f32_i32, "V4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_cube_v4f16_i32, "V4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1d_v4f32_i32, "vV4fiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1d_v4f16_i32, "vV4hiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1darray_v4f32_i32, "vV4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1darray_v4f16_i32, "vV4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2d_f32_i32, "vfiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2d_v4f32_i32, "vV4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2d_v4f16_i32, "vV4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2darray_f32_i32, "vfiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2darray_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2darray_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_3d_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_3d_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_cube_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_cube_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1d_v4f32_i32, "vV4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1d_v4f16_i32, "vV4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1darray_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1darray_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2d_f32_i32, "vfiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2d_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2d_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2darray_f32_i32, "vfiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2darray_v4f32_i32, "vV4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2darray_v4f16_i32, "vV4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_3d_v4f32_i32, "vV4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_3d_v4f16_i32, "vV4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_cube_v4f32_i32, "vV4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_cube_v4f16_i32, "vV4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1d_v4f32_f32, "V4fifQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1d_v4f16_f32, "V4hifQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1darray_v4f32_f32, "V4fiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1darray_v4f16_f32, "V4hiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2d_f32_f32, "fiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2d_v4f32_f32, "V4fiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2d_v4f16_f32, "V4hiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2darray_f32_f32, "fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2darray_v4f32_f32, "V4fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2darray_v4f16_f32, "V4hifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_3d_v4f32_f32, "V4fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_3d_v4f16_f32, "V4hifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_cube_v4f32_f32, "V4fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_cube_v4f16_f32, "V4hifffQtV4ibii", "nc", "image-insts") + #undef BUILTIN #undef TARGET_BUILTIN diff --git a/clang/include/clang/Basic/arm_sve.td b/clang/include/clang/Basic/arm_sve.td index 9a9a9874..d2b7b78b 100644 --- a/clang/include/clang/Basic/arm_sve.td +++ b/clang/include/clang/Basic/arm_sve.td @@ -953,7 +953,7 @@ def SVCVTNT_BF16_F32 : SInst<"svcvtnt_bf16[_f32]", "$$Pd", "f", MergeOp1, "aar // SVCVTNT_X_BF16_F32 : Implemented as macro by SveEmitter.cpp } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVCVTLT_F32_F16 : SInstCvtMX<"svcvtlt_f32[_f16]", "ddPh", "dPh", "f", "aarch64_sve_fcvtlt_f32f16">; defm SVCVTLT_F64_F32 : SInstCvtMX<"svcvtlt_f64[_f32]", "ddPh", "dPh", "d", "aarch64_sve_fcvtlt_f64f32">; @@ -1243,7 +1243,7 @@ let SVETargetGuard = "sve2p1|sme2", SMETargetGuard = "sve2p1|sme2" in { //////////////////////////////////////////////////////////////////////////////// // SVE2 WhileGE/GT -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVWHILEGE_S32 : SInst<"svwhilege_{d}[_{1}]", "Pkk", "PcPsPiPl", MergeNone, "aarch64_sve_whilege", [IsOverloadWhileOrMultiVecCvt, VerifyRuntimeMode]>; def SVWHILEGE_S64 : SInst<"svwhilege_{d}[_{1}]", "Pll", "PcPsPiPl", MergeNone, "aarch64_sve_whilege", [IsOverloadWhileOrMultiVecCvt, VerifyRuntimeMode]>; def SVWHILEGT_S32 : SInst<"svwhilegt_{d}[_{1}]", "Pkk", "PcPsPiPl", MergeNone, "aarch64_sve_whilegt", [IsOverloadWhileOrMultiVecCvt, VerifyRuntimeMode]>; @@ -1268,7 +1268,7 @@ let SVETargetGuard = "sve2p1|sme2", SMETargetGuard = "sve2p1|sme2" in { //////////////////////////////////////////////////////////////////////////////// // SVE2 - Uniform DSP operations -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVQADD_S : SInstZPZZ<"svqadd", "csli", "aarch64_sve_sqadd", "aarch64_sve_sqadd">; defm SVQADD_U : SInstZPZZ<"svqadd", "UcUsUiUl", "aarch64_sve_uqadd", "aarch64_sve_uqadd">; defm SVHADD_S : SInstZPZZ<"svhadd", "csli", "aarch64_sve_shadd", "aarch64_sve_shadd">; @@ -1303,7 +1303,7 @@ multiclass SInstZPZxZ<string name, string types, string pat_v, string pat_n, str def _N_Z : SInst<name # "[_n_{d}]", pat_n, types, MergeZero, intrinsic, flags>; } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVQRSHL_S : SInstZPZxZ<"svqrshl", "csil", "dPdx", "dPdK", "aarch64_sve_sqrshl", [VerifyRuntimeMode]>; defm SVQRSHL_U : SInstZPZxZ<"svqrshl", "UcUsUiUl", "dPdx", "dPdK", "aarch64_sve_uqrshl", [VerifyRuntimeMode]>; defm SVQSHL_S : SInstZPZxZ<"svqshl", "csil", "dPdx", "dPdK", "aarch64_sve_sqshl", [VerifyRuntimeMode]>; @@ -1357,7 +1357,7 @@ multiclass SInstPairwise<string name, string types, string intrinsic, list<FlagT def _X : SInst<name # "[_{d}]", "dPdd", types, MergeAny, intrinsic, flags>; } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVADDP : SInstPairwise<"svaddp", "csliUcUsUiUl", "aarch64_sve_addp", [VerifyRuntimeMode]>; defm SVADDP_F : SInstPairwise<"svaddp", "hfd", "aarch64_sve_faddp", [VerifyRuntimeMode]>; defm SVMAXNMP : SInstPairwise<"svmaxnmp", "hfd", "aarch64_sve_fmaxnmp", [VerifyRuntimeMode]>; @@ -1373,7 +1373,7 @@ defm SVMINP_U : SInstPairwise<"svminp", "UcUsUiUl", "aarch64_sve_uminp", [ //////////////////////////////////////////////////////////////////////////////// // SVE2 - Widening pairwise arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVADALP_S_M : SInst<"svadalp[_{d}]", "dPdh", "sil", MergeOp1, "aarch64_sve_sadalp", [VerifyRuntimeMode]>; def SVADALP_S_X : SInst<"svadalp[_{d}]", "dPdh", "sil", MergeAny, "aarch64_sve_sadalp", [VerifyRuntimeMode]>; def SVADALP_S_Z : SInst<"svadalp[_{d}]", "dPdh", "sil", MergeZero, "aarch64_sve_sadalp", [VerifyRuntimeMode]>; @@ -1387,7 +1387,7 @@ def SVADALP_U_Z : SInst<"svadalp[_{d}]", "dPdh", "UsUiUl", MergeZero, "aarch64_s // SVE2 - Bitwise ternary logical instructions // -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVBCAX : SInst<"svbcax[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bcax", [VerifyRuntimeMode]>; def SVBSL : SInst<"svbsl[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl", [VerifyRuntimeMode]>; def SVBSL1N : SInst<"svbsl1n[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl1n", [VerifyRuntimeMode]>; @@ -1407,7 +1407,7 @@ def SVXAR_N : SInst<"svxar[_n_{d}]", "dddi", "csilUcUsUiUl", MergeNone, "aar //////////////////////////////////////////////////////////////////////////////// // SVE2 - Large integer arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVADCLB : SInst<"svadclb[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_adclb", [VerifyRuntimeMode]>; def SVADCLT : SInst<"svadclt[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_adclt", [VerifyRuntimeMode]>; def SVSBCLB : SInst<"svsbclb[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_sbclb", [VerifyRuntimeMode]>; @@ -1422,7 +1422,7 @@ def SVSBCLT_N : SInst<"svsbclt[_n_{d}]", "ddda", "UiUl", MergeNone, "aarch64_sve //////////////////////////////////////////////////////////////////////////////// // SVE2 - Multiplication by indexed elements -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVMLA_LANE_2 : SInst<"svmla_lane[_{d}]", "ddddi", "silUsUiUl", MergeNone, "aarch64_sve_mla_lane", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckLaneIndex, 2>]>; def SVMLS_LANE_2 : SInst<"svmls_lane[_{d}]", "ddddi", "silUsUiUl", MergeNone, "aarch64_sve_mls_lane", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckLaneIndex, 2>]>; def SVMUL_LANE_2 : SInst<"svmul_lane[_{d}]", "dddi", "silUsUiUl", MergeNone, "aarch64_sve_mul_lane", [VerifyRuntimeMode], [ImmCheck<2, ImmCheckLaneIndex, 1>]>; @@ -1430,7 +1430,7 @@ def SVMUL_LANE_2 : SInst<"svmul_lane[_{d}]", "dddi", "silUsUiUl", MergeNone, "a //////////////////////////////////////////////////////////////////////////////// // SVE2 - Uniform complex integer arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVCADD : SInst<"svcadd[_{d}]", "dddi", "csilUcUsUiUl", MergeNone, "aarch64_sve_cadd_x", [VerifyRuntimeMode], [ImmCheck<2, ImmCheckComplexRot90_270>]>; def SVSQCADD : SInst<"svqcadd[_{d}]", "dddi", "csil", MergeNone, "aarch64_sve_sqcadd_x", [VerifyRuntimeMode], [ImmCheck<2, ImmCheckComplexRot90_270>]>; def SVCMLA : SInst<"svcmla[_{d}]", "ddddi", "csilUcUsUiUl", MergeNone, "aarch64_sve_cmla_x", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckComplexRotAll90>]>; @@ -1457,7 +1457,7 @@ multiclass SInstWideDSPWide<string name, string types, string intrinsic> { def _N : SInst<name # "[_n_{d}]", "ddR", types, MergeNone, intrinsic, [VerifyRuntimeMode]>; } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVABALB_S : SInstWideDSPAcc<"svabalb", "sil", "aarch64_sve_sabalb">; defm SVABALB_U : SInstWideDSPAcc<"svabalb", "UsUiUl", "aarch64_sve_uabalb">; defm SVABALT_S : SInstWideDSPAcc<"svabalt", "sil", "aarch64_sve_sabalt">; @@ -1536,7 +1536,7 @@ def SVQDMULLT_LANE : SInst<"svqdmullt_lane[_{d}]", "dhhi", "il", MergeNone, " //////////////////////////////////////////////////////////////////////////////// // SVE2 - Narrowing DSP operations -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVADDHNB : SInst<"svaddhnb[_{d}]", "hdd", "silUsUiUl", MergeNone, "aarch64_sve_addhnb", [VerifyRuntimeMode]>; def SVADDHNT : SInst<"svaddhnt[_{d}]", "hhdd", "silUsUiUl", MergeNone, "aarch64_sve_addhnt", [VerifyRuntimeMode]>; def SVRADDHNB : SInst<"svraddhnb[_{d}]", "hdd", "silUsUiUl", MergeNone, "aarch64_sve_raddhnb", [VerifyRuntimeMode]>; @@ -1576,7 +1576,7 @@ def SVQRSHRNT_U : SInst<"svqrshrnt[_n_{d}]", "hhdi", "UsUiUl", MergeNone, "a //////////////////////////////////////////////////////////////////////////////// // SVE2 - Unary narrowing operations -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVQXTNB_S : SInst<"svqxtnb[_{d}]", "hd", "sil", MergeNone, "aarch64_sve_sqxtnb", [VerifyRuntimeMode]>; def SVQXTNB_U : SInst<"svqxtnb[_{d}]", "hd", "UsUiUl", MergeNone, "aarch64_sve_uqxtnb", [VerifyRuntimeMode]>; def SVQXTUNB_S : SInst<"svqxtunb[_{d}]", "ed", "sil", MergeNone, "aarch64_sve_sqxtunb", [VerifyRuntimeMode]>; @@ -1589,7 +1589,7 @@ def SVQXTUNT_S : SInst<"svqxtunt[_{d}]", "eed", "sil", MergeNone, "aarch64_sv //////////////////////////////////////////////////////////////////////////////// // SVE2 - Widening complex integer arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVADDLBT : SInstWideDSPLong<"svaddlbt", "sil", "aarch64_sve_saddlbt">; defm SVSUBLBT : SInstWideDSPLong<"svsublbt", "sil", "aarch64_sve_ssublbt">; defm SVSUBLTB : SInstWideDSPLong<"svsubltb", "sil", "aarch64_sve_ssubltb">; @@ -1723,7 +1723,7 @@ def SVSTNT1W_SCATTER_INDEX_S : MInst<"svstnt1w_scatter[_{2}base]_index[_{d}]", " //////////////////////////////////////////////////////////////////////////////// // SVE2 - Polynomial arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVEORBT : SInst<"sveorbt[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eorbt", [VerifyRuntimeMode]>; def SVEORBT_N : SInst<"sveorbt[_n_{d}]", "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_eorbt", [VerifyRuntimeMode]>; def SVEORTB : SInst<"sveortb[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eortb", [VerifyRuntimeMode]>; @@ -1744,7 +1744,7 @@ def SVPMULLT_PAIR_N : SInst<"svpmullt_pair[_n_{d}]", "dda", "UcUi", MergeNone, //////////////////////////////////////////////////////////////////////////////// // SVE2 - Complex integer dot product -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVCDOT : SInst<"svcdot[_{d}]", "ddqqi", "il", MergeNone, "aarch64_sve_cdot", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckComplexRotAll90>]>; def SVCDOT_LANE : SInst<"svcdot_lane[_{d}]", "ddqqii", "il", MergeNone, "aarch64_sve_cdot_lane", [VerifyRuntimeMode], [ImmCheck<4, ImmCheckComplexRotAll90>, ImmCheck<3, ImmCheckLaneIndexDot, 2>]>; } @@ -1752,7 +1752,7 @@ def SVCDOT_LANE : SInst<"svcdot_lane[_{d}]", "ddqqii", "il", MergeNone, "aarch //////////////////////////////////////////////////////////////////////////////// // SVE2 - Floating-point widening multiply-accumulate -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVMLALB_F : SInst<"svmlalb[_{d}]", "ddhh", "f", MergeNone, "aarch64_sve_fmlalb", [VerifyRuntimeMode]>; def SVMLALB_F_N : SInst<"svmlalb[_n_{d}]", "ddhR", "f", MergeNone, "aarch64_sve_fmlalb", [VerifyRuntimeMode]>; def SVMLALB_F_LANE : SInst<"svmlalb_lane[_{d}]", "ddhhi", "f", MergeNone, "aarch64_sve_fmlalb_lane", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckLaneIndex, 2>]>; @@ -1770,7 +1770,7 @@ def SVMLSLT_F_LANE : SInst<"svmlslt_lane[_{d}]", "ddhhi", "f", MergeNone, "aarch //////////////////////////////////////////////////////////////////////////////// // SVE2 - Floating-point integer binary logarithm -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVLOGB_M : SInst<"svlogb[_{d}]", "xxPd", "hfd", MergeOp1, "aarch64_sve_flogb", [VerifyRuntimeMode]>; def SVLOGB_X : SInst<"svlogb[_{d}]", "xPd", "hfd", MergeAnyExp, "aarch64_sve_flogb", [VerifyRuntimeMode]>; def SVLOGB_Z : SInst<"svlogb[_{d}]", "xPd", "hfd", MergeZeroExp, "aarch64_sve_flogb", [VerifyRuntimeMode]>; @@ -1794,7 +1794,7 @@ def SVNMATCH : SInst<"svnmatch[_{d}]", "PPdd", "csUcUs", MergeNone, "aarch64_sve //////////////////////////////////////////////////////////////////////////////// // SVE2 - Contiguous conflict detection -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVWHILERW_B : SInst<"svwhilerw[_{1}]", "Pcc", "cUc", MergeNone, "aarch64_sve_whilerw_b", [IsOverloadWhileRW, VerifyRuntimeMode]>; def SVWHILERW_H : SInst<"svwhilerw[_{1}]", "Pcc", "sUshb", MergeNone, "aarch64_sve_whilerw_h", [IsOverloadWhileRW, VerifyRuntimeMode]>; def SVWHILERW_S : SInst<"svwhilerw[_{1}]", "Pcc", "iUif", MergeNone, "aarch64_sve_whilerw_s", [IsOverloadWhileRW, VerifyRuntimeMode]>; @@ -1808,14 +1808,14 @@ def SVWHILEWR_D : SInst<"svwhilewr[_{1}]", "Pcc", "lUld", MergeNone, "aarch64_sv //////////////////////////////////////////////////////////////////////////////// // SVE2 - Extended table lookup/permute -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVTBL2 : SInst<"svtbl2[_{d}]", "d2u", "csilUcUsUiUlhfdb", MergeNone, "", [VerifyRuntimeMode]>; def SVTBX : SInst<"svtbx[_{d}]", "dddu", "csilUcUsUiUlhfdb", MergeNone, "aarch64_sve_tbx", [VerifyRuntimeMode]>; } //////////////////////////////////////////////////////////////////////////////// // SVE2 - Lookup table -let SVETargetGuard = "sve2,lut", SMETargetGuard = "sme2,lut" in { +let SVETargetGuard = "(sve2|sme2),lut", SMETargetGuard = "sme2,lut" in { def SVLUTI2_B : SInst<"svluti2_lane[_{d}]", "dd[i", "cUc", MergeNone, "aarch64_sve_luti2_lane", [VerifyRuntimeMode], [ImmCheck<2, ImmCheck0_3>]>; def SVLUTI2_H : SInst<"svluti2_lane[_{d}]", "dd[i", "sUshb", MergeNone, "aarch64_sve_luti2_lane", [VerifyRuntimeMode], [ImmCheck<2, ImmCheck0_7>]>; @@ -1841,7 +1841,7 @@ def SVPMULLT_PAIR_U64 : SInst<"svpmullt_pair[_{d}]", "ddd", "Ul", MergeNone, def SVPMULLT_PAIR_N_U64 : SInst<"svpmullt_pair[_n_{d}]", "dda", "Ul", MergeNone, "aarch64_sve_pmullt_pair", [VerifyRuntimeMode]>; } -let SVETargetGuard = "sve-sha3", SMETargetGuard = "sve-sha3,sme2p1" in { +let SVETargetGuard = "sve-sha3", SMETargetGuard = "sme2p1,sve-sha3" in { def SVRAX1 : SInst<"svrax1[_{d}]", "ddd", "lUl", MergeNone, "aarch64_sve_rax1", [IsOverloadNone, VerifyRuntimeMode]>; } @@ -1884,7 +1884,7 @@ def SVFMAXQV : SInst<"svmaxqv[_{d}]", "{Pd", "hfd", MergeNone, "aarch64_sve_ def SVFMINQV : SInst<"svminqv[_{d}]", "{Pd", "hfd", MergeNone, "aarch64_sve_fminqv", [IsReductionQV, VerifyRuntimeMode]>; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { def SVPEXT_SINGLE : SInst<"svpext_lane_{d}", "P}i", "QcQsQiQl", MergeNone, "aarch64_sve_pext", [VerifyRuntimeMode], [ImmCheck<1, ImmCheck0_3>]>; def SVPEXT_X2 : SInst<"svpext_lane_{d}_x2", "2.P}i", "QcQsQiQl", MergeNone, "aarch64_sve_pext_x2", [VerifyRuntimeMode], [ImmCheck<1, ImmCheck0_1>]>; @@ -1923,7 +1923,7 @@ multiclass MultiVecLoad<string i> { def SV # NAME # D_VNUM_X4 : MInst<"sv" # i # "_vnum" # "[_{2}]_x4", "4}cl", "lUld", [IsStructLoad, VerifyRuntimeMode], MemEltTyDefault, "aarch64_sve_" # i # "_pn_x4">; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { defm LD1 : MultiVecLoad<"ld1">; defm LDNT1 : MultiVecLoad<"ldnt1">; } @@ -1948,7 +1948,7 @@ multiclass MultiVecStore<string i> { def SV # NAME # D_VNUM_X4 : MInst<"sv" # i # "_vnum" # "[_{2}_x4]", "v}pl4", "lUld", [IsStructStore, VerifyRuntimeMode], MemEltTyDefault, "aarch64_sve_" # i # "_pn_x4">; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { defm ST1 : MultiVecStore<"st1">; defm STNT1 : MultiVecStore<"stnt1">; } @@ -1972,7 +1972,7 @@ def SVUCLAMP : SInst<"svclamp[_{d}]", "dddd", "UcUsUiUl", MergeNone, "aarch64_sv defm SVREVD : SInstZPZ<"svrevd", "csilUcUsUiUlmbhfd", "aarch64_sve_revd">; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { def SVPTRUE_COUNT : SInst<"svptrue_{d}", "}v", "QcQsQiQl", MergeNone, "aarch64_sve_ptrue_{d}", [IsOverloadNone, VerifyRuntimeMode], []>; def SVCNTP_COUNT : SInst<"svcntp_{d}", "n}i", "QcQsQiQl", MergeNone, "aarch64_sve_cntp_{d}", [IsOverloadNone, VerifyRuntimeMode], [ImmCheck<1, ImmCheck2_4_Mul2>]>; @@ -2131,7 +2131,7 @@ let SVETargetGuard = InvalidMode, SMETargetGuard = "sme2,faminmax" in { def FAMAX_X4 : Inst<"svamax[_{d}_x4]", "444", "hfd", MergeNone, "aarch64_sme_famax_x4", [IsStreaming], []>; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { def REINTERPRET_SVBOOL_TO_SVCOUNT : Inst<"svreinterpret[_c]", "}P", "Pc", MergeNone, "", [VerifyRuntimeMode], []>; def REINTERPRET_SVCOUNT_TO_SVBOOL : Inst<"svreinterpret[_b]", "P}", "Pc", MergeNone, "", [VerifyRuntimeMode], []>; } @@ -2225,9 +2225,9 @@ let SVETargetGuard = InvalidMode, SMETargetGuard = "sme-f16f16" in { // Multi-vector saturating extract narrow // let SVETargetGuard = InvalidMode, SMETargetGuard = "sme2" in { - def SVQCVT_S16_S32_X2 : SInst<"svqcvt_s16[_{d}_x2]", "h2.d", "i", MergeNone, "aarch64_sve_sqcvt_x2", [IsStreaming], []>; - def SVQCVT_U16_U32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "Ui", MergeNone, "aarch64_sve_uqcvt_x2", [IsStreaming], []>; - def SVQCVT_U16_S32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "i", MergeNone, "aarch64_sve_sqcvtu_x2", [IsStreaming], []>; + def SVQCVT_S16_S32_X2 : SInst<"svqcvt_s16[_{d}_x2]", "h2.d", "i", MergeNone, "aarch64_sve_sqcvt_x2", [IsStreaming], []>; + def SVQCVT_U16_U32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "Ui", MergeNone, "aarch64_sve_uqcvt_x2", [IsStreaming], []>; + def SVQCVT_U16_S32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "i", MergeNone, "aarch64_sve_sqcvtu_x2", [IsStreaming], []>; def SVQCVT_S8_S32_X4 : SInst<"svqcvt_s8[_{d}_x4]", "q4.d", "i", MergeNone, "aarch64_sve_sqcvt_x4", [IsStreaming], []>; def SVQCVT_U8_U32_X4 : SInst<"svqcvt_u8[_{d}_x4]", "b4.d", "Ui", MergeNone, "aarch64_sve_uqcvt_x4", [IsStreaming], []>; @@ -2316,12 +2316,12 @@ let SVETargetGuard = "sve2p1|sme2", SMETargetGuard = "sve2p1|sme2" in { def SVBFMLSLT_LANE : SInst<"svbfmlslt_lane[_{d}]", "dd$$i", "f", MergeNone, "aarch64_sve_bfmlslt_lane", [IsOverloadNone, VerifyRuntimeMode], [ImmCheck<3, ImmCheck0_7>]>; } -let SVETargetGuard = "sve2,faminmax", SMETargetGuard = "sme2,faminmax" in { +let SVETargetGuard = "(sve2|sme2),faminmax", SMETargetGuard = "sme2,faminmax" in { defm SVAMIN : SInstZPZZ<"svamin", "hfd", "aarch64_sve_famin", "aarch64_sve_famin_u">; defm SVAMAX : SInstZPZZ<"svamax", "hfd", "aarch64_sve_famax", "aarch64_sve_famax_u">; } -let SVETargetGuard = "sve2,fp8", SMETargetGuard = "sme2,fp8" in { +let SVETargetGuard = "(sve2|sme2),fp8", SMETargetGuard = "sme2,fp8" in { // SVE FP8 widening conversions // 8-bit floating-point convert to BFloat16/Float16 diff --git a/clang/include/clang/Driver/Distro.h b/clang/include/clang/Driver/Distro.h index 5c25592..008de0d 100644 --- a/clang/include/clang/Driver/Distro.h +++ b/clang/include/clang/Driver/Distro.h @@ -48,11 +48,6 @@ public: Fedora, Gentoo, OpenSUSE, - UbuntuHardy, - UbuntuIntrepid, - UbuntuJaunty, - UbuntuKarmic, - UbuntuLucid, UbuntuMaverick, UbuntuNatty, UbuntuOneiric, @@ -135,7 +130,7 @@ public: } bool IsUbuntu() const { - return DistroVal >= UbuntuHardy && DistroVal <= UbuntuQuesting; + return DistroVal >= UbuntuMaverick && DistroVal <= UbuntuQuesting; } bool IsAlpineLinux() const { return DistroVal == AlpineLinux; } diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index e301cf1..0d2316f 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -2173,7 +2173,7 @@ private: if (Tok.is(tok::kw___attribute)) { ParsedAttributes Attrs(AttrFactory); ParseGNUAttributes(Attrs, LateAttrs, &D); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); } } @@ -2272,7 +2272,7 @@ private: if (isAllowedCXX11AttributeSpecifier()) { ParsedAttributes Attrs(AttrFactory); ParseCXX11Attributes(Attrs); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); } } @@ -2292,7 +2292,7 @@ private: ParsedAttributes AttrsWithRange(AttrFactory); ParseMicrosoftAttributes(AttrsWithRange); AttrsParsed = !AttrsWithRange.empty(); - Attrs.takeAllFrom(AttrsWithRange); + Attrs.takeAllAppendingFrom(AttrsWithRange); } return AttrsParsed; } @@ -5175,7 +5175,7 @@ private: if (Tok.is(tok::colon)) { ParsedAttributes Attrs(AttrFactory); ParseHLSLAnnotations(Attrs, EndLoc, CouldBeBitField); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); return true; } return false; diff --git a/clang/include/clang/Sema/DeclSpec.h b/clang/include/clang/Sema/DeclSpec.h index c1a99a1..43a48c9 100644 --- a/clang/include/clang/Sema/DeclSpec.h +++ b/clang/include/clang/Sema/DeclSpec.h @@ -835,7 +835,7 @@ public: /// \endcode /// void addAttributes(const ParsedAttributesView &AL) { - Attrs.addAll(AL.begin(), AL.end()); + Attrs.prepend(AL.begin(), AL.end()); } bool hasAttributes() const { return !Attrs.empty(); } @@ -843,8 +843,8 @@ public: ParsedAttributes &getAttributes() { return Attrs; } const ParsedAttributes &getAttributes() const { return Attrs; } - void takeAttributesFrom(ParsedAttributes &attrs) { - Attrs.takeAllFrom(attrs); + void takeAttributesAppendingingFrom(ParsedAttributes &attrs) { + Attrs.takeAllAppendingFrom(attrs); } /// Finish - This does final analysis of the declspec, issuing diagnostics for @@ -2327,7 +2327,7 @@ public: void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc) { DeclTypeInfo.push_back(TI); - DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end()); + DeclTypeInfo.back().getAttrs().prepend(attrs.begin(), attrs.end()); getAttributePool().takeAllFrom(attrs.getPool()); if (!EndLoc.isInvalid()) @@ -2638,8 +2638,8 @@ public: return InventedTemplateParameterList; } - /// takeAttributes - Takes attributes from the given parsed-attributes - /// set and add them to this declarator. + /// takeAttributesAppending - Takes attributes from the given + /// ParsedAttributes set and add them to this declarator. /// /// These examples both add 3 attributes to "var": /// short int var __attribute__((aligned(16),common,deprecated)); @@ -2647,8 +2647,8 @@ public: /// __attribute__((common,deprecated)); /// /// Also extends the range of the declarator. - void takeAttributes(ParsedAttributes &attrs) { - Attrs.takeAllFrom(attrs); + void takeAttributesAppending(ParsedAttributes &attrs) { + Attrs.takeAllAppendingFrom(attrs); if (attrs.Range.getEnd().isValid()) SetRangeEnd(attrs.Range.getEnd()); diff --git a/clang/include/clang/Sema/ParsedAttr.h b/clang/include/clang/Sema/ParsedAttr.h index 2edee7e..5387f9f 100644 --- a/clang/include/clang/Sema/ParsedAttr.h +++ b/clang/include/clang/Sema/ParsedAttr.h @@ -856,19 +856,19 @@ public: friend class ParsedAttributesView; }; - void addAll(iterator B, iterator E) { + void prepend(iterator B, iterator E) { AttrList.insert(AttrList.begin(), B.I, E.I); } - void addAll(const_iterator B, const_iterator E) { + void prepend(const_iterator B, const_iterator E) { AttrList.insert(AttrList.begin(), B.I, E.I); } - void addAllAtEnd(iterator B, iterator E) { + void append(iterator B, iterator E) { AttrList.insert(AttrList.end(), B.I, E.I); } - void addAllAtEnd(const_iterator B, const_iterator E) { + void append(const_iterator B, const_iterator E) { AttrList.insert(AttrList.end(), B.I, E.I); } @@ -943,18 +943,18 @@ public: AttributePool &getPool() const { return pool; } - void takeAllFrom(ParsedAttributes &Other) { + void takeAllPrependingFrom(ParsedAttributes &Other) { assert(&Other != this && "ParsedAttributes can't take attributes from itself"); - addAll(Other.begin(), Other.end()); + prepend(Other.begin(), Other.end()); Other.clearListOnly(); pool.takeAllFrom(Other.pool); } - void takeAllAtEndFrom(ParsedAttributes &Other) { + void takeAllAppendingFrom(ParsedAttributes &Other) { assert(&Other != this && "ParsedAttributes can't take attributes from itself"); - addAllAtEnd(Other.begin(), Other.end()); + append(Other.begin(), Other.end()); Other.clearListOnly(); pool.takeAllFrom(Other.pool); } diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h index 448e402..389f17d 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h @@ -42,19 +42,6 @@ private: llvm::StringLiteral Name; }; -class BoolEPStat : public EntryPointStat { - std::optional<bool> Value = {}; - -public: - explicit BoolEPStat(llvm::StringLiteral Name); - unsigned value() const { return Value && *Value; } - void set(bool V) { - assert(!Value.has_value()); - Value = V; - } - void reset() { Value = {}; } -}; - // used by CounterEntryPointTranslationUnitStat class CounterEPStat : public EntryPointStat { using EntryPointStat::EntryPointStat; diff --git a/clang/lib/Analysis/CMakeLists.txt b/clang/lib/Analysis/CMakeLists.txt index 5a26f3e..1dbd415 100644 --- a/clang/lib/Analysis/CMakeLists.txt +++ b/clang/lib/Analysis/CMakeLists.txt @@ -21,8 +21,6 @@ add_clang_library(clangAnalysis FixitUtil.cpp IntervalPartition.cpp IssueHash.cpp - LifetimeAnnotations.cpp - LifetimeSafety.cpp LiveVariables.cpp MacroExpansionContext.cpp ObjCNoReturn.cpp @@ -51,3 +49,4 @@ add_clang_library(clangAnalysis add_subdirectory(plugins) add_subdirectory(FlowSensitive) +add_subdirectory(LifetimeSafety) diff --git a/clang/lib/Analysis/LifetimeSafety.cpp b/clang/lib/Analysis/LifetimeSafety.cpp deleted file mode 100644 index 6196ec3..0000000 --- a/clang/lib/Analysis/LifetimeSafety.cpp +++ /dev/null @@ -1,1546 +0,0 @@ -//===- LifetimeSafety.cpp - C++ Lifetime Safety Analysis -*--------- C++-*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -#include "clang/Analysis/Analyses/LifetimeSafety.h" -#include "clang/AST/Decl.h" -#include "clang/AST/Expr.h" -#include "clang/AST/StmtVisitor.h" -#include "clang/AST/Type.h" -#include "clang/Analysis/Analyses/LifetimeAnnotations.h" -#include "clang/Analysis/Analyses/PostOrderCFGView.h" -#include "clang/Analysis/AnalysisDeclContext.h" -#include "clang/Analysis/CFG.h" -#include "clang/Analysis/FlowSensitive/DataflowWorklist.h" -#include "llvm/ADT/FoldingSet.h" -#include "llvm/ADT/ImmutableMap.h" -#include "llvm/ADT/ImmutableSet.h" -#include "llvm/ADT/PointerUnion.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/Support/Debug.h" -#include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/TimeProfiler.h" -#include <cstdint> -#include <memory> -#include <optional> - -namespace clang::lifetimes { -namespace internal { - -/// Represents the storage location being borrowed, e.g., a specific stack -/// variable. -/// TODO: Model access paths of other types, e.g., s.field, heap and globals. -struct AccessPath { - const clang::ValueDecl *D; - - AccessPath(const clang::ValueDecl *D) : D(D) {} -}; - -/// Information about a single borrow, or "Loan". A loan is created when a -/// reference or pointer is created. -struct Loan { - /// TODO: Represent opaque loans. - /// TODO: Represent nullptr: loans to no path. Accessing it UB! Currently it - /// is represented as empty LoanSet - LoanID ID; - AccessPath Path; - /// The expression that creates the loan, e.g., &x. - const Expr *IssueExpr; - - Loan(LoanID id, AccessPath path, const Expr *IssueExpr) - : ID(id), Path(path), IssueExpr(IssueExpr) {} - - void dump(llvm::raw_ostream &OS) const { - OS << ID << " (Path: "; - OS << Path.D->getNameAsString() << ")"; - } -}; - -/// An Origin is a symbolic identifier that represents the set of possible -/// loans a pointer-like object could hold at any given time. -/// TODO: Enhance the origin model to handle complex types, pointer -/// indirection and reborrowing. The plan is to move from a single origin per -/// variable/expression to a "list of origins" governed by the Type. -/// For example, the type 'int**' would have two origins. -/// See discussion: -/// https://github.com/llvm/llvm-project/pull/142313/commits/0cd187b01e61b200d92ca0b640789c1586075142#r2137644238 -struct Origin { - OriginID ID; - /// A pointer to the AST node that this origin represents. This union - /// distinguishes between origins from declarations (variables or parameters) - /// and origins from expressions. - llvm::PointerUnion<const clang::ValueDecl *, const clang::Expr *> Ptr; - - Origin(OriginID ID, const clang::ValueDecl *D) : ID(ID), Ptr(D) {} - Origin(OriginID ID, const clang::Expr *E) : ID(ID), Ptr(E) {} - - const clang::ValueDecl *getDecl() const { - return Ptr.dyn_cast<const clang::ValueDecl *>(); - } - const clang::Expr *getExpr() const { - return Ptr.dyn_cast<const clang::Expr *>(); - } -}; - -/// Manages the creation, storage and retrieval of loans. -class LoanManager { -public: - LoanManager() = default; - - Loan &addLoan(AccessPath Path, const Expr *IssueExpr) { - AllLoans.emplace_back(getNextLoanID(), Path, IssueExpr); - return AllLoans.back(); - } - - const Loan &getLoan(LoanID ID) const { - assert(ID.Value < AllLoans.size()); - return AllLoans[ID.Value]; - } - llvm::ArrayRef<Loan> getLoans() const { return AllLoans; } - -private: - LoanID getNextLoanID() { return NextLoanID++; } - - LoanID NextLoanID{0}; - /// TODO(opt): Profile and evaluate the usefullness of small buffer - /// optimisation. - llvm::SmallVector<Loan> AllLoans; -}; - -/// Manages the creation, storage, and retrieval of origins for pointer-like -/// variables and expressions. -class OriginManager { -public: - OriginManager() = default; - - Origin &addOrigin(OriginID ID, const clang::ValueDecl &D) { - AllOrigins.emplace_back(ID, &D); - return AllOrigins.back(); - } - Origin &addOrigin(OriginID ID, const clang::Expr &E) { - AllOrigins.emplace_back(ID, &E); - return AllOrigins.back(); - } - - // TODO: Mark this method as const once we remove the call to getOrCreate. - OriginID get(const Expr &E) { - auto It = ExprToOriginID.find(&E); - if (It != ExprToOriginID.end()) - return It->second; - // If the expression itself has no specific origin, and it's a reference - // to a declaration, its origin is that of the declaration it refers to. - // For pointer types, where we don't pre-emptively create an origin for the - // DeclRefExpr itself. - if (const auto *DRE = dyn_cast<DeclRefExpr>(&E)) - return get(*DRE->getDecl()); - // TODO: This should be an assert(It != ExprToOriginID.end()). The current - // implementation falls back to getOrCreate to avoid crashing on - // yet-unhandled pointer expressions, creating an empty origin for them. - return getOrCreate(E); - } - - OriginID get(const ValueDecl &D) { - auto It = DeclToOriginID.find(&D); - // TODO: This should be an assert(It != DeclToOriginID.end()). The current - // implementation falls back to getOrCreate to avoid crashing on - // yet-unhandled pointer expressions, creating an empty origin for them. - if (It == DeclToOriginID.end()) - return getOrCreate(D); - - return It->second; - } - - OriginID getOrCreate(const Expr &E) { - auto It = ExprToOriginID.find(&E); - if (It != ExprToOriginID.end()) - return It->second; - - OriginID NewID = getNextOriginID(); - addOrigin(NewID, E); - ExprToOriginID[&E] = NewID; - return NewID; - } - - const Origin &getOrigin(OriginID ID) const { - assert(ID.Value < AllOrigins.size()); - return AllOrigins[ID.Value]; - } - - llvm::ArrayRef<Origin> getOrigins() const { return AllOrigins; } - - OriginID getOrCreate(const ValueDecl &D) { - auto It = DeclToOriginID.find(&D); - if (It != DeclToOriginID.end()) - return It->second; - OriginID NewID = getNextOriginID(); - addOrigin(NewID, D); - DeclToOriginID[&D] = NewID; - return NewID; - } - - void dump(OriginID OID, llvm::raw_ostream &OS) const { - OS << OID << " ("; - Origin O = getOrigin(OID); - if (const ValueDecl *VD = O.getDecl()) - OS << "Decl: " << VD->getNameAsString(); - else if (const Expr *E = O.getExpr()) - OS << "Expr: " << E->getStmtClassName(); - else - OS << "Unknown"; - OS << ")"; - } - -private: - OriginID getNextOriginID() { return NextOriginID++; } - - OriginID NextOriginID{0}; - /// TODO(opt): Profile and evaluate the usefullness of small buffer - /// optimisation. - llvm::SmallVector<Origin> AllOrigins; - llvm::DenseMap<const clang::ValueDecl *, OriginID> DeclToOriginID; - llvm::DenseMap<const clang::Expr *, OriginID> ExprToOriginID; -}; - -/// An abstract base class for a single, atomic lifetime-relevant event. -class Fact { - -public: - enum class Kind : uint8_t { - /// A new loan is issued from a borrow expression (e.g., &x). - Issue, - /// A loan expires as its underlying storage is freed (e.g., variable goes - /// out of scope). - Expire, - /// An origin is propagated from a source to a destination (e.g., p = q). - /// This can also optionally kill the destination origin before flowing into - /// it. Otherwise, the source's loan set is merged into the destination's - /// loan set. - OriginFlow, - /// An origin escapes the function by flowing into the return value. - ReturnOfOrigin, - /// An origin is used (eg. appears as l-value expression like DeclRefExpr). - Use, - /// A marker for a specific point in the code, for testing. - TestPoint, - }; - -private: - Kind K; - -protected: - Fact(Kind K) : K(K) {} - -public: - virtual ~Fact() = default; - Kind getKind() const { return K; } - - template <typename T> const T *getAs() const { - if (T::classof(this)) - return static_cast<const T *>(this); - return nullptr; - } - - virtual void dump(llvm::raw_ostream &OS, const LoanManager &, - const OriginManager &) const { - OS << "Fact (Kind: " << static_cast<int>(K) << ")\n"; - } -}; - -class IssueFact : public Fact { - LoanID LID; - OriginID OID; - -public: - static bool classof(const Fact *F) { return F->getKind() == Kind::Issue; } - - IssueFact(LoanID LID, OriginID OID) : Fact(Kind::Issue), LID(LID), OID(OID) {} - LoanID getLoanID() const { return LID; } - OriginID getOriginID() const { return OID; } - void dump(llvm::raw_ostream &OS, const LoanManager &LM, - const OriginManager &OM) const override { - OS << "Issue ("; - LM.getLoan(getLoanID()).dump(OS); - OS << ", ToOrigin: "; - OM.dump(getOriginID(), OS); - OS << ")\n"; - } -}; - -class ExpireFact : public Fact { - LoanID LID; - SourceLocation ExpiryLoc; - -public: - static bool classof(const Fact *F) { return F->getKind() == Kind::Expire; } - - ExpireFact(LoanID LID, SourceLocation ExpiryLoc) - : Fact(Kind::Expire), LID(LID), ExpiryLoc(ExpiryLoc) {} - - LoanID getLoanID() const { return LID; } - SourceLocation getExpiryLoc() const { return ExpiryLoc; } - - void dump(llvm::raw_ostream &OS, const LoanManager &LM, - const OriginManager &) const override { - OS << "Expire ("; - LM.getLoan(getLoanID()).dump(OS); - OS << ")\n"; - } -}; - -class OriginFlowFact : public Fact { - OriginID OIDDest; - OriginID OIDSrc; - // True if the destination origin should be killed (i.e., its current loans - // cleared) before the source origin's loans are flowed into it. - bool KillDest; - -public: - static bool classof(const Fact *F) { - return F->getKind() == Kind::OriginFlow; - } - - OriginFlowFact(OriginID OIDDest, OriginID OIDSrc, bool KillDest) - : Fact(Kind::OriginFlow), OIDDest(OIDDest), OIDSrc(OIDSrc), - KillDest(KillDest) {} - - OriginID getDestOriginID() const { return OIDDest; } - OriginID getSrcOriginID() const { return OIDSrc; } - bool getKillDest() const { return KillDest; } - - void dump(llvm::raw_ostream &OS, const LoanManager &, - const OriginManager &OM) const override { - OS << "OriginFlow (Dest: "; - OM.dump(getDestOriginID(), OS); - OS << ", Src: "; - OM.dump(getSrcOriginID(), OS); - OS << (getKillDest() ? "" : ", Merge"); - OS << ")\n"; - } -}; - -class ReturnOfOriginFact : public Fact { - OriginID OID; - -public: - static bool classof(const Fact *F) { - return F->getKind() == Kind::ReturnOfOrigin; - } - - ReturnOfOriginFact(OriginID OID) : Fact(Kind::ReturnOfOrigin), OID(OID) {} - OriginID getReturnedOriginID() const { return OID; } - void dump(llvm::raw_ostream &OS, const LoanManager &, - const OriginManager &OM) const override { - OS << "ReturnOfOrigin ("; - OM.dump(getReturnedOriginID(), OS); - OS << ")\n"; - } -}; - -class UseFact : public Fact { - const Expr *UseExpr; - // True if this use is a write operation (e.g., left-hand side of assignment). - // Write operations are exempted from use-after-free checks. - bool IsWritten = false; - -public: - static bool classof(const Fact *F) { return F->getKind() == Kind::Use; } - - UseFact(const Expr *UseExpr) : Fact(Kind::Use), UseExpr(UseExpr) {} - - OriginID getUsedOrigin(const OriginManager &OM) const { - // TODO: Remove const cast and make OriginManager::get as const. - return const_cast<OriginManager &>(OM).get(*UseExpr); - } - const Expr *getUseExpr() const { return UseExpr; } - void markAsWritten() { IsWritten = true; } - bool isWritten() const { return IsWritten; } - - void dump(llvm::raw_ostream &OS, const LoanManager &, - const OriginManager &OM) const override { - OS << "Use ("; - OM.dump(getUsedOrigin(OM), OS); - OS << ", " << (isWritten() ? "Write" : "Read") << ")\n"; - } -}; - -/// A dummy-fact used to mark a specific point in the code for testing. -/// It is generated by recognizing a `void("__lifetime_test_point_...")` cast. -class TestPointFact : public Fact { - StringRef Annotation; - -public: - static bool classof(const Fact *F) { return F->getKind() == Kind::TestPoint; } - - explicit TestPointFact(StringRef Annotation) - : Fact(Kind::TestPoint), Annotation(Annotation) {} - - StringRef getAnnotation() const { return Annotation; } - - void dump(llvm::raw_ostream &OS, const LoanManager &, - const OriginManager &) const override { - OS << "TestPoint (Annotation: \"" << getAnnotation() << "\")\n"; - } -}; - -class FactManager { -public: - llvm::ArrayRef<const Fact *> getFacts(const CFGBlock *B) const { - auto It = BlockToFactsMap.find(B); - if (It != BlockToFactsMap.end()) - return It->second; - return {}; - } - - void addBlockFacts(const CFGBlock *B, llvm::ArrayRef<Fact *> NewFacts) { - if (!NewFacts.empty()) - BlockToFactsMap[B].assign(NewFacts.begin(), NewFacts.end()); - } - - template <typename FactType, typename... Args> - FactType *createFact(Args &&...args) { - void *Mem = FactAllocator.Allocate<FactType>(); - return new (Mem) FactType(std::forward<Args>(args)...); - } - - void dump(const CFG &Cfg, AnalysisDeclContext &AC) const { - llvm::dbgs() << "==========================================\n"; - llvm::dbgs() << " Lifetime Analysis Facts:\n"; - llvm::dbgs() << "==========================================\n"; - if (const Decl *D = AC.getDecl()) - if (const auto *ND = dyn_cast<NamedDecl>(D)) - llvm::dbgs() << "Function: " << ND->getQualifiedNameAsString() << "\n"; - // Print blocks in the order as they appear in code for a stable ordering. - for (const CFGBlock *B : *AC.getAnalysis<PostOrderCFGView>()) { - llvm::dbgs() << " Block B" << B->getBlockID() << ":\n"; - auto It = BlockToFactsMap.find(B); - if (It != BlockToFactsMap.end()) { - for (const Fact *F : It->second) { - llvm::dbgs() << " "; - F->dump(llvm::dbgs(), LoanMgr, OriginMgr); - } - } - llvm::dbgs() << " End of Block\n"; - } - } - - LoanManager &getLoanMgr() { return LoanMgr; } - OriginManager &getOriginMgr() { return OriginMgr; } - -private: - LoanManager LoanMgr; - OriginManager OriginMgr; - llvm::DenseMap<const clang::CFGBlock *, llvm::SmallVector<const Fact *>> - BlockToFactsMap; - llvm::BumpPtrAllocator FactAllocator; -}; - -class FactGenerator : public ConstStmtVisitor<FactGenerator> { - using Base = ConstStmtVisitor<FactGenerator>; - -public: - FactGenerator(FactManager &FactMgr, AnalysisDeclContext &AC) - : FactMgr(FactMgr), AC(AC) {} - - void run() { - llvm::TimeTraceScope TimeProfile("FactGenerator"); - // Iterate through the CFG blocks in reverse post-order to ensure that - // initializations and destructions are processed in the correct sequence. - for (const CFGBlock *Block : *AC.getAnalysis<PostOrderCFGView>()) { - CurrentBlockFacts.clear(); - for (unsigned I = 0; I < Block->size(); ++I) { - const CFGElement &Element = Block->Elements[I]; - if (std::optional<CFGStmt> CS = Element.getAs<CFGStmt>()) - Visit(CS->getStmt()); - else if (std::optional<CFGAutomaticObjDtor> DtorOpt = - Element.getAs<CFGAutomaticObjDtor>()) - handleDestructor(*DtorOpt); - } - FactMgr.addBlockFacts(Block, CurrentBlockFacts); - } - } - - void VisitDeclStmt(const DeclStmt *DS) { - for (const Decl *D : DS->decls()) - if (const auto *VD = dyn_cast<VarDecl>(D)) - if (hasOrigin(VD)) - if (const Expr *InitExpr = VD->getInit()) - killAndFlowOrigin(*VD, *InitExpr); - } - - void VisitDeclRefExpr(const DeclRefExpr *DRE) { - handleUse(DRE); - // For non-pointer/non-view types, a reference to the variable's storage - // is a borrow. We create a loan for it. - // For pointer/view types, we stick to the existing model for now and do - // not create an extra origin for the l-value expression itself. - - // TODO: A single origin for a `DeclRefExpr` for a pointer or view type is - // not sufficient to model the different levels of indirection. The current - // single-origin model cannot distinguish between a loan to the variable's - // storage and a loan to what it points to. A multi-origin model would be - // required for this. - if (!isPointerType(DRE->getType())) { - if (const Loan *L = createLoan(DRE)) { - OriginID ExprOID = FactMgr.getOriginMgr().getOrCreate(*DRE); - CurrentBlockFacts.push_back( - FactMgr.createFact<IssueFact>(L->ID, ExprOID)); - } - } - } - - void VisitCXXConstructExpr(const CXXConstructExpr *CCE) { - if (isGslPointerType(CCE->getType())) { - handleGSLPointerConstruction(CCE); - return; - } - } - - void VisitCXXMemberCallExpr(const CXXMemberCallExpr *MCE) { - // Specifically for conversion operators, - // like `std::string_view p = std::string{};` - if (isGslPointerType(MCE->getType()) && - isa<CXXConversionDecl>(MCE->getCalleeDecl())) { - // The argument is the implicit object itself. - handleFunctionCall(MCE, MCE->getMethodDecl(), - {MCE->getImplicitObjectArgument()}, - /*IsGslConstruction=*/true); - } - if (const CXXMethodDecl *Method = MCE->getMethodDecl()) { - // Construct the argument list, with the implicit 'this' object as the - // first argument. - llvm::SmallVector<const Expr *, 4> Args; - Args.push_back(MCE->getImplicitObjectArgument()); - Args.append(MCE->getArgs(), MCE->getArgs() + MCE->getNumArgs()); - - handleFunctionCall(MCE, Method, Args, /*IsGslConstruction=*/false); - } - } - - void VisitCallExpr(const CallExpr *CE) { - handleFunctionCall(CE, CE->getDirectCallee(), - {CE->getArgs(), CE->getNumArgs()}); - } - - void VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *N) { - /// TODO: Handle nullptr expr as a special 'null' loan. Uninitialized - /// pointers can use the same type of loan. - FactMgr.getOriginMgr().getOrCreate(*N); - } - - void VisitImplicitCastExpr(const ImplicitCastExpr *ICE) { - if (!hasOrigin(ICE)) - return; - // An ImplicitCastExpr node itself gets an origin, which flows from the - // origin of its sub-expression (after stripping its own parens/casts). - killAndFlowOrigin(*ICE, *ICE->getSubExpr()); - } - - void VisitUnaryOperator(const UnaryOperator *UO) { - if (UO->getOpcode() == UO_AddrOf) { - const Expr *SubExpr = UO->getSubExpr(); - // Taking address of a pointer-type expression is not yet supported and - // will be supported in multi-origin model. - if (isPointerType(SubExpr->getType())) - return; - // The origin of an address-of expression (e.g., &x) is the origin of - // its sub-expression (x). This fact will cause the dataflow analysis - // to propagate any loans held by the sub-expression's origin to the - // origin of this UnaryOperator expression. - killAndFlowOrigin(*UO, *SubExpr); - } - } - - void VisitReturnStmt(const ReturnStmt *RS) { - if (const Expr *RetExpr = RS->getRetValue()) { - if (hasOrigin(RetExpr)) { - OriginID OID = FactMgr.getOriginMgr().getOrCreate(*RetExpr); - CurrentBlockFacts.push_back( - FactMgr.createFact<ReturnOfOriginFact>(OID)); - } - } - } - - void VisitBinaryOperator(const BinaryOperator *BO) { - if (BO->isAssignmentOp()) - handleAssignment(BO->getLHS(), BO->getRHS()); - } - - void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *OCE) { - // Assignment operators have special "kill-then-propagate" semantics - // and are handled separately. - if (OCE->isAssignmentOp() && OCE->getNumArgs() == 2) { - handleAssignment(OCE->getArg(0), OCE->getArg(1)); - return; - } - handleFunctionCall(OCE, OCE->getDirectCallee(), - {OCE->getArgs(), OCE->getNumArgs()}, - /*IsGslConstruction=*/false); - } - - void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *FCE) { - // Check if this is a test point marker. If so, we are done with this - // expression. - if (handleTestPoint(FCE)) - return; - if (isGslPointerType(FCE->getType())) - killAndFlowOrigin(*FCE, *FCE->getSubExpr()); - } - - void VisitInitListExpr(const InitListExpr *ILE) { - if (!hasOrigin(ILE)) - return; - // For list initialization with a single element, like `View{...}`, the - // origin of the list itself is the origin of its single element. - if (ILE->getNumInits() == 1) - killAndFlowOrigin(*ILE, *ILE->getInit(0)); - } - - void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *MTE) { - if (!hasOrigin(MTE)) - return; - // A temporary object's origin is the same as the origin of the - // expression that initializes it. - killAndFlowOrigin(*MTE, *MTE->getSubExpr()); - } - - void handleDestructor(const CFGAutomaticObjDtor &DtorOpt) { - /// TODO: Also handle trivial destructors (e.g., for `int` - /// variables) which will never have a CFGAutomaticObjDtor node. - /// TODO: Handle loans to temporaries. - /// TODO: Consider using clang::CFG::BuildOptions::AddLifetime to reuse the - /// lifetime ends. - const VarDecl *DestructedVD = DtorOpt.getVarDecl(); - if (!DestructedVD) - return; - // Iterate through all loans to see if any expire. - /// TODO(opt): Do better than a linear search to find loans associated with - /// 'DestructedVD'. - for (const Loan &L : FactMgr.getLoanMgr().getLoans()) { - const AccessPath &LoanPath = L.Path; - // Check if the loan is for a stack variable and if that variable - // is the one being destructed. - if (LoanPath.D == DestructedVD) - CurrentBlockFacts.push_back(FactMgr.createFact<ExpireFact>( - L.ID, DtorOpt.getTriggerStmt()->getEndLoc())); - } - } - -private: - static bool isGslPointerType(QualType QT) { - if (const auto *RD = QT->getAsCXXRecordDecl()) { - // We need to check the template definition for specializations. - if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) - return CTSD->getSpecializedTemplate() - ->getTemplatedDecl() - ->hasAttr<PointerAttr>(); - return RD->hasAttr<PointerAttr>(); - } - return false; - } - - static bool isPointerType(QualType QT) { - return QT->isPointerOrReferenceType() || isGslPointerType(QT); - } - // Check if a type has an origin. - static bool hasOrigin(const Expr *E) { - return E->isGLValue() || isPointerType(E->getType()); - } - - static bool hasOrigin(const VarDecl *VD) { - return isPointerType(VD->getType()); - } - - void handleGSLPointerConstruction(const CXXConstructExpr *CCE) { - assert(isGslPointerType(CCE->getType())); - if (CCE->getNumArgs() != 1) - return; - if (hasOrigin(CCE->getArg(0))) - killAndFlowOrigin(*CCE, *CCE->getArg(0)); - else - // This could be a new borrow. - handleFunctionCall(CCE, CCE->getConstructor(), - {CCE->getArgs(), CCE->getNumArgs()}, - /*IsGslConstruction=*/true); - } - - /// Checks if a call-like expression creates a borrow by passing a value to a - /// reference parameter, creating an IssueFact if it does. - /// \param IsGslConstruction True if this is a GSL construction where all - /// argument origins should flow to the returned origin. - void handleFunctionCall(const Expr *Call, const FunctionDecl *FD, - ArrayRef<const Expr *> Args, - bool IsGslConstruction = false) { - // Ignore functions returning values with no origin. - if (!FD || !hasOrigin(Call)) - return; - auto IsArgLifetimeBound = [FD](unsigned I) -> bool { - const ParmVarDecl *PVD = nullptr; - if (const auto *Method = dyn_cast<CXXMethodDecl>(FD); - Method && Method->isInstance()) { - if (I == 0) - // For the 'this' argument, the attribute is on the method itself. - return implicitObjectParamIsLifetimeBound(Method); - if ((I - 1) < Method->getNumParams()) - // For explicit arguments, find the corresponding parameter - // declaration. - PVD = Method->getParamDecl(I - 1); - } else if (I < FD->getNumParams()) - // For free functions or static methods. - PVD = FD->getParamDecl(I); - return PVD ? PVD->hasAttr<clang::LifetimeBoundAttr>() : false; - }; - if (Args.empty()) - return; - bool killedSrc = false; - for (unsigned I = 0; I < Args.size(); ++I) - if (IsGslConstruction || IsArgLifetimeBound(I)) { - if (!killedSrc) { - killedSrc = true; - killAndFlowOrigin(*Call, *Args[I]); - } else - flowOrigin(*Call, *Args[I]); - } - } - - /// Creates a loan for the storage path of a given declaration reference. - /// This function should be called whenever a DeclRefExpr represents a borrow. - /// \param DRE The declaration reference expression that initiates the borrow. - /// \return The new Loan on success, nullptr otherwise. - const Loan *createLoan(const DeclRefExpr *DRE) { - if (const auto *VD = dyn_cast<ValueDecl>(DRE->getDecl())) { - AccessPath Path(VD); - // The loan is created at the location of the DeclRefExpr. - return &FactMgr.getLoanMgr().addLoan(Path, DRE); - } - return nullptr; - } - - template <typename Destination, typename Source> - void flowOrigin(const Destination &D, const Source &S) { - OriginID DestOID = FactMgr.getOriginMgr().getOrCreate(D); - OriginID SrcOID = FactMgr.getOriginMgr().get(S); - CurrentBlockFacts.push_back(FactMgr.createFact<OriginFlowFact>( - DestOID, SrcOID, /*KillDest=*/false)); - } - - template <typename Destination, typename Source> - void killAndFlowOrigin(const Destination &D, const Source &S) { - OriginID DestOID = FactMgr.getOriginMgr().getOrCreate(D); - OriginID SrcOID = FactMgr.getOriginMgr().get(S); - CurrentBlockFacts.push_back( - FactMgr.createFact<OriginFlowFact>(DestOID, SrcOID, /*KillDest=*/true)); - } - - /// Checks if the expression is a `void("__lifetime_test_point_...")` cast. - /// If so, creates a `TestPointFact` and returns true. - bool handleTestPoint(const CXXFunctionalCastExpr *FCE) { - if (!FCE->getType()->isVoidType()) - return false; - - const auto *SubExpr = FCE->getSubExpr()->IgnoreParenImpCasts(); - if (const auto *SL = dyn_cast<StringLiteral>(SubExpr)) { - llvm::StringRef LiteralValue = SL->getString(); - const std::string Prefix = "__lifetime_test_point_"; - - if (LiteralValue.starts_with(Prefix)) { - StringRef Annotation = LiteralValue.drop_front(Prefix.length()); - CurrentBlockFacts.push_back( - FactMgr.createFact<TestPointFact>(Annotation)); - return true; - } - } - return false; - } - - void handleAssignment(const Expr *LHSExpr, const Expr *RHSExpr) { - if (!hasOrigin(LHSExpr)) - return; - // Find the underlying variable declaration for the left-hand side. - if (const auto *DRE_LHS = - dyn_cast<DeclRefExpr>(LHSExpr->IgnoreParenImpCasts())) { - markUseAsWrite(DRE_LHS); - if (const auto *VD_LHS = dyn_cast<ValueDecl>(DRE_LHS->getDecl())) { - // Kill the old loans of the destination origin and flow the new loans - // from the source origin. - killAndFlowOrigin(*VD_LHS, *RHSExpr); - } - } - } - - // A DeclRefExpr will be treated as a use of the referenced decl. It will be - // checked for use-after-free unless it is later marked as being written to - // (e.g. on the left-hand side of an assignment). - void handleUse(const DeclRefExpr *DRE) { - if (isPointerType(DRE->getType())) { - UseFact *UF = FactMgr.createFact<UseFact>(DRE); - CurrentBlockFacts.push_back(UF); - assert(!UseFacts.contains(DRE)); - UseFacts[DRE] = UF; - } - } - - void markUseAsWrite(const DeclRefExpr *DRE) { - if (!isPointerType(DRE->getType())) - return; - assert(UseFacts.contains(DRE)); - UseFacts[DRE]->markAsWritten(); - } - - FactManager &FactMgr; - AnalysisDeclContext &AC; - llvm::SmallVector<Fact *> CurrentBlockFacts; - // To distinguish between reads and writes for use-after-free checks, this map - // stores the `UseFact` for each `DeclRefExpr`. We initially identify all - // `DeclRefExpr`s as "read" uses. When an assignment is processed, the use - // corresponding to the left-hand side is updated to be a "write", thereby - // exempting it from the check. - llvm::DenseMap<const DeclRefExpr *, UseFact *> UseFacts; -}; - -// ========================================================================= // -// Generic Dataflow Analysis -// ========================================================================= // - -enum class Direction { Forward, Backward }; - -/// A `ProgramPoint` identifies a location in the CFG by pointing to a specific -/// `Fact`. identified by a lifetime-related event (`Fact`). -/// -/// A `ProgramPoint` has "after" semantics: it represents the location -/// immediately after its corresponding `Fact`. -using ProgramPoint = const Fact *; - -/// A generic, policy-based driver for dataflow analyses. It combines -/// the dataflow runner and the transferer logic into a single class hierarchy. -/// -/// The derived class is expected to provide: -/// - A `Lattice` type. -/// - `StringRef getAnalysisName() const` -/// - `Lattice getInitialState();` The initial state of the analysis. -/// - `Lattice join(Lattice, Lattice);` Merges states from multiple CFG paths. -/// - `Lattice transfer(Lattice, const FactType&);` Defines how a single -/// lifetime-relevant `Fact` transforms the lattice state. Only overloads -/// for facts relevant to the analysis need to be implemented. -/// -/// \tparam Derived The CRTP derived class that implements the specific -/// analysis. -/// \tparam LatticeType The dataflow lattice used by the analysis. -/// \tparam Dir The direction of the analysis (Forward or Backward). -/// TODO: Maybe use the dataflow framework! The framework might need changes -/// to support the current comparison done at block-entry. -template <typename Derived, typename LatticeType, Direction Dir> -class DataflowAnalysis { -public: - using Lattice = LatticeType; - using Base = DataflowAnalysis<Derived, Lattice, Dir>; - -private: - const CFG &Cfg; - AnalysisDeclContext &AC; - - /// The dataflow state before a basic block is processed. - llvm::DenseMap<const CFGBlock *, Lattice> InStates; - /// The dataflow state after a basic block is processed. - llvm::DenseMap<const CFGBlock *, Lattice> OutStates; - /// The dataflow state at a Program Point. - /// In a forward analysis, this is the state after the Fact at that point has - /// been applied, while in a backward analysis, it is the state before. - llvm::DenseMap<ProgramPoint, Lattice> PerPointStates; - - static constexpr bool isForward() { return Dir == Direction::Forward; } - -protected: - FactManager &AllFacts; - - explicit DataflowAnalysis(const CFG &C, AnalysisDeclContext &AC, - FactManager &F) - : Cfg(C), AC(AC), AllFacts(F) {} - -public: - void run() { - Derived &D = static_cast<Derived &>(*this); - llvm::TimeTraceScope Time(D.getAnalysisName()); - - using Worklist = - std::conditional_t<Dir == Direction::Forward, ForwardDataflowWorklist, - BackwardDataflowWorklist>; - Worklist W(Cfg, AC); - - const CFGBlock *Start = isForward() ? &Cfg.getEntry() : &Cfg.getExit(); - InStates[Start] = D.getInitialState(); - W.enqueueBlock(Start); - - while (const CFGBlock *B = W.dequeue()) { - Lattice StateIn = *getInState(B); - Lattice StateOut = transferBlock(B, StateIn); - OutStates[B] = StateOut; - for (const CFGBlock *AdjacentB : isForward() ? B->succs() : B->preds()) { - if (!AdjacentB) - continue; - std::optional<Lattice> OldInState = getInState(AdjacentB); - Lattice NewInState = - !OldInState ? StateOut : D.join(*OldInState, StateOut); - // Enqueue the adjacent block if its in-state has changed or if we have - // never seen it. - if (!OldInState || NewInState != *OldInState) { - InStates[AdjacentB] = NewInState; - W.enqueueBlock(AdjacentB); - } - } - } - } - -protected: - Lattice getState(ProgramPoint P) const { return PerPointStates.lookup(P); } - - std::optional<Lattice> getInState(const CFGBlock *B) const { - auto It = InStates.find(B); - if (It == InStates.end()) - return std::nullopt; - return It->second; - } - - Lattice getOutState(const CFGBlock *B) const { return OutStates.lookup(B); } - - void dump() const { - const Derived *D = static_cast<const Derived *>(this); - llvm::dbgs() << "==========================================\n"; - llvm::dbgs() << D->getAnalysisName() << " results:\n"; - llvm::dbgs() << "==========================================\n"; - const CFGBlock &B = isForward() ? Cfg.getExit() : Cfg.getEntry(); - getOutState(&B).dump(llvm::dbgs()); - } - -private: - /// Computes the state at one end of a block by applying all its facts - /// sequentially to a given state from the other end. - Lattice transferBlock(const CFGBlock *Block, Lattice State) { - auto Facts = AllFacts.getFacts(Block); - if constexpr (isForward()) { - for (const Fact *F : Facts) { - State = transferFact(State, F); - PerPointStates[F] = State; - } - } else { - for (const Fact *F : llvm::reverse(Facts)) { - // In backward analysis, capture the state before applying the fact. - PerPointStates[F] = State; - State = transferFact(State, F); - } - } - return State; - } - - Lattice transferFact(Lattice In, const Fact *F) { - assert(F); - Derived *D = static_cast<Derived *>(this); - switch (F->getKind()) { - case Fact::Kind::Issue: - return D->transfer(In, *F->getAs<IssueFact>()); - case Fact::Kind::Expire: - return D->transfer(In, *F->getAs<ExpireFact>()); - case Fact::Kind::OriginFlow: - return D->transfer(In, *F->getAs<OriginFlowFact>()); - case Fact::Kind::ReturnOfOrigin: - return D->transfer(In, *F->getAs<ReturnOfOriginFact>()); - case Fact::Kind::Use: - return D->transfer(In, *F->getAs<UseFact>()); - case Fact::Kind::TestPoint: - return D->transfer(In, *F->getAs<TestPointFact>()); - } - llvm_unreachable("Unknown fact kind"); - } - -public: - Lattice transfer(Lattice In, const IssueFact &) { return In; } - Lattice transfer(Lattice In, const ExpireFact &) { return In; } - Lattice transfer(Lattice In, const OriginFlowFact &) { return In; } - Lattice transfer(Lattice In, const ReturnOfOriginFact &) { return In; } - Lattice transfer(Lattice In, const UseFact &) { return In; } - Lattice transfer(Lattice In, const TestPointFact &) { return In; } -}; - -namespace utils { - -/// Computes the union of two ImmutableSets. -template <typename T> -static llvm::ImmutableSet<T> join(llvm::ImmutableSet<T> A, - llvm::ImmutableSet<T> B, - typename llvm::ImmutableSet<T>::Factory &F) { - if (A.getHeight() < B.getHeight()) - std::swap(A, B); - for (const T &E : B) - A = F.add(A, E); - return A; -} - -/// Describes the strategy for joining two `ImmutableMap` instances, primarily -/// differing in how they handle keys that are unique to one of the maps. -/// -/// A `Symmetric` join is universally correct, while an `Asymmetric` join -/// serves as a performance optimization. The latter is applicable only when the -/// join operation possesses a left identity element, allowing for a more -/// efficient, one-sided merge. -enum class JoinKind { - /// A symmetric join applies the `JoinValues` operation to keys unique to - /// either map, ensuring that values from both maps contribute to the result. - Symmetric, - /// An asymmetric join preserves keys unique to the first map as-is, while - /// applying the `JoinValues` operation only to keys unique to the second map. - Asymmetric, -}; - -/// Computes the key-wise union of two ImmutableMaps. -// TODO(opt): This key-wise join is a performance bottleneck. A more -// efficient merge could be implemented using a Patricia Trie or HAMT -// instead of the current AVL-tree-based ImmutableMap. -template <typename K, typename V, typename Joiner> -static llvm::ImmutableMap<K, V> -join(const llvm::ImmutableMap<K, V> &A, const llvm::ImmutableMap<K, V> &B, - typename llvm::ImmutableMap<K, V>::Factory &F, Joiner JoinValues, - JoinKind Kind) { - if (A.getHeight() < B.getHeight()) - return join(B, A, F, JoinValues, Kind); - - // For each element in B, join it with the corresponding element in A - // (or with an empty value if it doesn't exist in A). - llvm::ImmutableMap<K, V> Res = A; - for (const auto &Entry : B) { - const K &Key = Entry.first; - const V &ValB = Entry.second; - Res = F.add(Res, Key, JoinValues(A.lookup(Key), &ValB)); - } - if (Kind == JoinKind::Symmetric) { - for (const auto &Entry : A) { - const K &Key = Entry.first; - const V &ValA = Entry.second; - if (!B.contains(Key)) - Res = F.add(Res, Key, JoinValues(&ValA, nullptr)); - } - } - return Res; -} -} // namespace utils - -// ========================================================================= // -// Loan Propagation Analysis -// ========================================================================= // - -/// Represents the dataflow lattice for loan propagation. -/// -/// This lattice tracks which loans each origin may hold at a given program -/// point.The lattice has a finite height: An origin's loan set is bounded by -/// the total number of loans in the function. -/// TODO(opt): To reduce the lattice size, propagate origins of declarations, -/// not expressions, because expressions are not visible across blocks. -struct LoanPropagationLattice { - /// The map from an origin to the set of loans it contains. - OriginLoanMap Origins = OriginLoanMap(nullptr); - - explicit LoanPropagationLattice(const OriginLoanMap &S) : Origins(S) {} - LoanPropagationLattice() = default; - - bool operator==(const LoanPropagationLattice &Other) const { - return Origins == Other.Origins; - } - bool operator!=(const LoanPropagationLattice &Other) const { - return !(*this == Other); - } - - void dump(llvm::raw_ostream &OS) const { - OS << "LoanPropagationLattice State:\n"; - if (Origins.isEmpty()) - OS << " <empty>\n"; - for (const auto &Entry : Origins) { - if (Entry.second.isEmpty()) - OS << " Origin " << Entry.first << " contains no loans\n"; - for (const LoanID &LID : Entry.second) - OS << " Origin " << Entry.first << " contains Loan " << LID << "\n"; - } - } -}; - -/// The analysis that tracks which loans belong to which origins. -class LoanPropagationAnalysis - : public DataflowAnalysis<LoanPropagationAnalysis, LoanPropagationLattice, - Direction::Forward> { - OriginLoanMap::Factory &OriginLoanMapFactory; - LoanSet::Factory &LoanSetFactory; - -public: - LoanPropagationAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F, - OriginLoanMap::Factory &OriginLoanMapFactory, - LoanSet::Factory &LoanSetFactory) - : DataflowAnalysis(C, AC, F), OriginLoanMapFactory(OriginLoanMapFactory), - LoanSetFactory(LoanSetFactory) {} - - using Base::transfer; - - StringRef getAnalysisName() const { return "LoanPropagation"; } - - Lattice getInitialState() { return Lattice{}; } - - /// Merges two lattices by taking the union of loans for each origin. - // TODO(opt): Keep the state small by removing origins which become dead. - Lattice join(Lattice A, Lattice B) { - OriginLoanMap JoinedOrigins = utils::join( - A.Origins, B.Origins, OriginLoanMapFactory, - [&](const LoanSet *S1, const LoanSet *S2) { - assert((S1 || S2) && "unexpectedly merging 2 empty sets"); - if (!S1) - return *S2; - if (!S2) - return *S1; - return utils::join(*S1, *S2, LoanSetFactory); - }, - // Asymmetric join is a performance win. For origins present only on one - // branch, the loan set can be carried over as-is. - utils::JoinKind::Asymmetric); - return Lattice(JoinedOrigins); - } - - /// A new loan is issued to the origin. Old loans are erased. - Lattice transfer(Lattice In, const IssueFact &F) { - OriginID OID = F.getOriginID(); - LoanID LID = F.getLoanID(); - return LoanPropagationLattice(OriginLoanMapFactory.add( - In.Origins, OID, - LoanSetFactory.add(LoanSetFactory.getEmptySet(), LID))); - } - - /// A flow from source to destination. If `KillDest` is true, this replaces - /// the destination's loans with the source's. Otherwise, the source's loans - /// are merged into the destination's. - Lattice transfer(Lattice In, const OriginFlowFact &F) { - OriginID DestOID = F.getDestOriginID(); - OriginID SrcOID = F.getSrcOriginID(); - - LoanSet DestLoans = - F.getKillDest() ? LoanSetFactory.getEmptySet() : getLoans(In, DestOID); - LoanSet SrcLoans = getLoans(In, SrcOID); - LoanSet MergedLoans = utils::join(DestLoans, SrcLoans, LoanSetFactory); - - return LoanPropagationLattice( - OriginLoanMapFactory.add(In.Origins, DestOID, MergedLoans)); - } - - LoanSet getLoans(OriginID OID, ProgramPoint P) const { - return getLoans(getState(P), OID); - } - -private: - LoanSet getLoans(Lattice L, OriginID OID) const { - if (auto *Loans = L.Origins.lookup(OID)) - return *Loans; - return LoanSetFactory.getEmptySet(); - } -}; - -// ========================================================================= // -// Live Origins Analysis -// ========================================================================= // -// -// A backward dataflow analysis that determines which origins are "live" at each -// program point. An origin is "live" at a program point if there's a potential -// future use of the pointer it represents. Liveness is "generated" by a read of -// origin's loan set (e.g., a `UseFact`) and is "killed" (i.e., it stops being -// live) when its loan set is overwritten (e.g. a OriginFlow killing the -// destination origin). -// -// This information is used for detecting use-after-free errors, as it allows us -// to check if a live origin holds a loan to an object that has already expired. -// ========================================================================= // - -/// Information about why an origin is live at a program point. -struct LivenessInfo { - /// The use that makes the origin live. If liveness is propagated from - /// multiple uses along different paths, this will point to the use appearing - /// earlier in the translation unit. - /// This is 'null' when the origin is not live. - const UseFact *CausingUseFact; - /// The kind of liveness of the origin. - /// `Must`: The origin is live on all control-flow paths from the current - /// point to the function's exit (i.e. the current point is dominated by a set - /// of uses). - /// `Maybe`: indicates it is live on some but not all paths. - /// - /// This determines the diagnostic's confidence level. - /// `Must`-be-alive at expiration implies a definite use-after-free, - /// while `Maybe`-be-alive suggests a potential one on some paths. - LivenessKind Kind; - - LivenessInfo() : CausingUseFact(nullptr), Kind(LivenessKind::Dead) {} - LivenessInfo(const UseFact *UF, LivenessKind K) - : CausingUseFact(UF), Kind(K) {} - - bool operator==(const LivenessInfo &Other) const { - return CausingUseFact == Other.CausingUseFact && Kind == Other.Kind; - } - bool operator!=(const LivenessInfo &Other) const { return !(*this == Other); } - - void Profile(llvm::FoldingSetNodeID &IDBuilder) const { - IDBuilder.AddPointer(CausingUseFact); - IDBuilder.Add(Kind); - } -}; - -using LivenessMap = llvm::ImmutableMap<OriginID, LivenessInfo>; - -/// The dataflow lattice for origin liveness analysis. -/// It tracks which origins are live, why they're live (which UseFact), -/// and the confidence level of that liveness. -struct LivenessLattice { - LivenessMap LiveOrigins; - - LivenessLattice() : LiveOrigins(nullptr) {}; - - explicit LivenessLattice(LivenessMap L) : LiveOrigins(L) {} - - bool operator==(const LivenessLattice &Other) const { - return LiveOrigins == Other.LiveOrigins; - } - - bool operator!=(const LivenessLattice &Other) const { - return !(*this == Other); - } - - void dump(llvm::raw_ostream &OS, const OriginManager &OM) const { - if (LiveOrigins.isEmpty()) - OS << " <empty>\n"; - for (const auto &Entry : LiveOrigins) { - OriginID OID = Entry.first; - const LivenessInfo &Info = Entry.second; - OS << " "; - OM.dump(OID, OS); - OS << " is "; - switch (Info.Kind) { - case LivenessKind::Must: - OS << "definitely"; - break; - case LivenessKind::Maybe: - OS << "maybe"; - break; - case LivenessKind::Dead: - llvm_unreachable("liveness kind of live origins should not be dead."); - } - OS << " live at this point\n"; - } - } -}; - -/// The analysis that tracks which origins are live, with granular information -/// about the causing use fact and confidence level. This is a backward -/// analysis. -class LiveOriginAnalysis - : public DataflowAnalysis<LiveOriginAnalysis, LivenessLattice, - Direction::Backward> { - FactManager &FactMgr; - LivenessMap::Factory &Factory; - -public: - LiveOriginAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F, - LivenessMap::Factory &SF) - : DataflowAnalysis(C, AC, F), FactMgr(F), Factory(SF) {} - using DataflowAnalysis<LiveOriginAnalysis, Lattice, - Direction::Backward>::transfer; - - StringRef getAnalysisName() const { return "LiveOrigins"; } - - Lattice getInitialState() { return Lattice(Factory.getEmptyMap()); } - - /// Merges two lattices by combining liveness information. - /// When the same origin has different confidence levels, we take the lower - /// one. - Lattice join(Lattice L1, Lattice L2) const { - LivenessMap Merged = L1.LiveOrigins; - // Take the earliest UseFact to make the join hermetic and commutative. - auto CombineUseFact = [](const UseFact &A, - const UseFact &B) -> const UseFact * { - return A.getUseExpr()->getExprLoc() < B.getUseExpr()->getExprLoc() ? &A - : &B; - }; - auto CombineLivenessKind = [](LivenessKind K1, - LivenessKind K2) -> LivenessKind { - assert(K1 != LivenessKind::Dead && "LivenessKind should not be dead."); - assert(K2 != LivenessKind::Dead && "LivenessKind should not be dead."); - // Only return "Must" if both paths are "Must", otherwise Maybe. - if (K1 == LivenessKind::Must && K2 == LivenessKind::Must) - return LivenessKind::Must; - return LivenessKind::Maybe; - }; - auto CombineLivenessInfo = [&](const LivenessInfo *L1, - const LivenessInfo *L2) -> LivenessInfo { - assert((L1 || L2) && "unexpectedly merging 2 empty sets"); - if (!L1) - return LivenessInfo(L2->CausingUseFact, LivenessKind::Maybe); - if (!L2) - return LivenessInfo(L1->CausingUseFact, LivenessKind::Maybe); - return LivenessInfo( - CombineUseFact(*L1->CausingUseFact, *L2->CausingUseFact), - CombineLivenessKind(L1->Kind, L2->Kind)); - }; - return Lattice(utils::join( - L1.LiveOrigins, L2.LiveOrigins, Factory, CombineLivenessInfo, - // A symmetric join is required here. If an origin is live on one - // branch but not the other, its confidence must be demoted to `Maybe`. - utils::JoinKind::Symmetric)); - } - - /// A read operation makes the origin live with definite confidence, as it - /// dominates this program point. A write operation kills the liveness of - /// the origin since it overwrites the value. - Lattice transfer(Lattice In, const UseFact &UF) { - OriginID OID = UF.getUsedOrigin(FactMgr.getOriginMgr()); - // Write kills liveness. - if (UF.isWritten()) - return Lattice(Factory.remove(In.LiveOrigins, OID)); - // Read makes origin live with definite confidence (dominates this point). - return Lattice(Factory.add(In.LiveOrigins, OID, - LivenessInfo(&UF, LivenessKind::Must))); - } - - /// Issuing a new loan to an origin kills its liveness. - Lattice transfer(Lattice In, const IssueFact &IF) { - return Lattice(Factory.remove(In.LiveOrigins, IF.getOriginID())); - } - - /// An OriginFlow kills the liveness of the destination origin if `KillDest` - /// is true. Otherwise, it propagates liveness from destination to source. - Lattice transfer(Lattice In, const OriginFlowFact &OF) { - if (!OF.getKillDest()) - return In; - return Lattice(Factory.remove(In.LiveOrigins, OF.getDestOriginID())); - } - - LivenessMap getLiveOrigins(ProgramPoint P) const { - return getState(P).LiveOrigins; - } - - // Dump liveness values on all test points in the program. - void dump(llvm::raw_ostream &OS, const LifetimeSafetyAnalysis &LSA) const { - llvm::dbgs() << "==========================================\n"; - llvm::dbgs() << getAnalysisName() << " results:\n"; - llvm::dbgs() << "==========================================\n"; - for (const auto &Entry : LSA.getTestPoints()) { - OS << "TestPoint: " << Entry.getKey() << "\n"; - getState(Entry.getValue()).dump(OS, FactMgr.getOriginMgr()); - } - } -}; - -// ========================================================================= // -// Lifetime checker and Error reporter -// ========================================================================= // - -/// Struct to store the complete context for a potential lifetime violation. -struct PendingWarning { - SourceLocation ExpiryLoc; // Where the loan expired. - const Expr *UseExpr; // Where the origin holding this loan was used. - Confidence ConfidenceLevel; -}; - -class LifetimeChecker { -private: - llvm::DenseMap<LoanID, PendingWarning> FinalWarningsMap; - LoanPropagationAnalysis &LoanPropagation; - LiveOriginAnalysis &LiveOrigins; - FactManager &FactMgr; - AnalysisDeclContext &ADC; - LifetimeSafetyReporter *Reporter; - -public: - LifetimeChecker(LoanPropagationAnalysis &LPA, LiveOriginAnalysis &LOA, - FactManager &FM, AnalysisDeclContext &ADC, - LifetimeSafetyReporter *Reporter) - : LoanPropagation(LPA), LiveOrigins(LOA), FactMgr(FM), ADC(ADC), - Reporter(Reporter) {} - - void run() { - llvm::TimeTraceScope TimeProfile("LifetimeChecker"); - for (const CFGBlock *B : *ADC.getAnalysis<PostOrderCFGView>()) - for (const Fact *F : FactMgr.getFacts(B)) - if (const auto *EF = F->getAs<ExpireFact>()) - checkExpiry(EF); - issuePendingWarnings(); - } - - /// Checks for use-after-free errors when a loan expires. - /// - /// This method examines all live origins at the expiry point and determines - /// if any of them hold the expiring loan. If so, it creates a pending - /// warning with the appropriate confidence level based on the liveness - /// information. The confidence reflects whether the origin is definitely - /// or maybe live at this point. - /// - /// Note: This implementation considers only the confidence of origin - /// liveness. Future enhancements could also consider the confidence of loan - /// propagation (e.g., a loan may only be held on some execution paths). - void checkExpiry(const ExpireFact *EF) { - LoanID ExpiredLoan = EF->getLoanID(); - LivenessMap Origins = LiveOrigins.getLiveOrigins(EF); - Confidence CurConfidence = Confidence::None; - const UseFact *BadUse = nullptr; - for (auto &[OID, LiveInfo] : Origins) { - LoanSet HeldLoans = LoanPropagation.getLoans(OID, EF); - if (!HeldLoans.contains(ExpiredLoan)) - continue; - // Loan is defaulted. - Confidence NewConfidence = livenessKindToConfidence(LiveInfo.Kind); - if (CurConfidence < NewConfidence) { - CurConfidence = NewConfidence; - BadUse = LiveInfo.CausingUseFact; - } - } - if (!BadUse) - return; - // We have a use-after-free. - Confidence LastConf = FinalWarningsMap.lookup(ExpiredLoan).ConfidenceLevel; - if (LastConf >= CurConfidence) - return; - FinalWarningsMap[ExpiredLoan] = {/*ExpiryLoc=*/EF->getExpiryLoc(), - /*UseExpr=*/BadUse->getUseExpr(), - /*ConfidenceLevel=*/CurConfidence}; - } - - static Confidence livenessKindToConfidence(LivenessKind K) { - switch (K) { - case LivenessKind::Must: - return Confidence::Definite; - case LivenessKind::Maybe: - return Confidence::Maybe; - case LivenessKind::Dead: - return Confidence::None; - } - llvm_unreachable("unknown liveness kind"); - } - - void issuePendingWarnings() { - if (!Reporter) - return; - for (const auto &[LID, Warning] : FinalWarningsMap) { - const Loan &L = FactMgr.getLoanMgr().getLoan(LID); - const Expr *IssueExpr = L.IssueExpr; - Reporter->reportUseAfterFree(IssueExpr, Warning.UseExpr, - Warning.ExpiryLoc, Warning.ConfidenceLevel); - } - } -}; - -// ========================================================================= // -// LifetimeSafetyAnalysis Class Implementation -// ========================================================================= // - -/// An object to hold the factories for immutable collections, ensuring -/// that all created states share the same underlying memory management. -struct LifetimeFactory { - llvm::BumpPtrAllocator Allocator; - OriginLoanMap::Factory OriginMapFactory{Allocator, /*canonicalize=*/false}; - LoanSet::Factory LoanSetFactory{Allocator, /*canonicalize=*/false}; - LivenessMap::Factory LivenessMapFactory{Allocator, /*canonicalize=*/false}; -}; - -// We need this here for unique_ptr with forward declared class. -LifetimeSafetyAnalysis::~LifetimeSafetyAnalysis() = default; - -LifetimeSafetyAnalysis::LifetimeSafetyAnalysis(AnalysisDeclContext &AC, - LifetimeSafetyReporter *Reporter) - : AC(AC), Reporter(Reporter), Factory(std::make_unique<LifetimeFactory>()), - FactMgr(std::make_unique<FactManager>()) {} - -void LifetimeSafetyAnalysis::run() { - llvm::TimeTraceScope TimeProfile("LifetimeSafetyAnalysis"); - - const CFG &Cfg = *AC.getCFG(); - DEBUG_WITH_TYPE("PrintCFG", Cfg.dump(AC.getASTContext().getLangOpts(), - /*ShowColors=*/true)); - - FactGenerator FactGen(*FactMgr, AC); - FactGen.run(); - DEBUG_WITH_TYPE("LifetimeFacts", FactMgr->dump(Cfg, AC)); - - /// TODO(opt): Consider optimizing individual blocks before running the - /// dataflow analysis. - /// 1. Expression Origins: These are assigned once and read at most once, - /// forming simple chains. These chains can be compressed into a single - /// assignment. - /// 2. Block-Local Loans: Origins of expressions are never read by other - /// blocks; only Decls are visible. Therefore, loans in a block that - /// never reach an Origin associated with a Decl can be safely dropped by - /// the analysis. - /// 3. Collapse ExpireFacts belonging to same source location into a single - /// Fact. - LoanPropagation = std::make_unique<LoanPropagationAnalysis>( - Cfg, AC, *FactMgr, Factory->OriginMapFactory, Factory->LoanSetFactory); - LoanPropagation->run(); - - LiveOrigins = std::make_unique<LiveOriginAnalysis>( - Cfg, AC, *FactMgr, Factory->LivenessMapFactory); - LiveOrigins->run(); - DEBUG_WITH_TYPE("LiveOrigins", LiveOrigins->dump(llvm::dbgs(), *this)); - - LifetimeChecker Checker(*LoanPropagation, *LiveOrigins, *FactMgr, AC, - Reporter); - Checker.run(); -} - -LoanSet LifetimeSafetyAnalysis::getLoansAtPoint(OriginID OID, - ProgramPoint PP) const { - assert(LoanPropagation && "Analysis has not been run."); - return LoanPropagation->getLoans(OID, PP); -} - -std::optional<OriginID> -LifetimeSafetyAnalysis::getOriginIDForDecl(const ValueDecl *D) const { - assert(FactMgr && "FactManager not initialized"); - // This assumes the OriginManager's `get` can find an existing origin. - // We might need a `find` method on OriginManager to avoid `getOrCreate` logic - // in a const-query context if that becomes an issue. - return FactMgr->getOriginMgr().get(*D); -} - -std::vector<LoanID> -LifetimeSafetyAnalysis::getLoanIDForVar(const VarDecl *VD) const { - assert(FactMgr && "FactManager not initialized"); - std::vector<LoanID> Result; - for (const Loan &L : FactMgr->getLoanMgr().getLoans()) - if (L.Path.D == VD) - Result.push_back(L.ID); - return Result; -} - -std::vector<std::pair<OriginID, LivenessKind>> -LifetimeSafetyAnalysis::getLiveOriginsAtPoint(ProgramPoint PP) const { - assert(LiveOrigins && "LiveOriginAnalysis has not been run."); - std::vector<std::pair<OriginID, LivenessKind>> Result; - for (auto &[OID, Info] : LiveOrigins->getLiveOrigins(PP)) - Result.push_back({OID, Info.Kind}); - return Result; -} - -llvm::StringMap<ProgramPoint> LifetimeSafetyAnalysis::getTestPoints() const { - assert(FactMgr && "FactManager not initialized"); - llvm::StringMap<ProgramPoint> AnnotationToPointMap; - for (const CFGBlock *Block : *AC.getCFG()) { - for (const Fact *F : FactMgr->getFacts(Block)) { - if (const auto *TPF = F->getAs<TestPointFact>()) { - StringRef PointName = TPF->getAnnotation(); - assert(AnnotationToPointMap.find(PointName) == - AnnotationToPointMap.end() && - "more than one test points with the same name"); - AnnotationToPointMap[PointName] = F; - } - } - } - return AnnotationToPointMap; -} -} // namespace internal - -void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC, - LifetimeSafetyReporter *Reporter) { - internal::LifetimeSafetyAnalysis Analysis(AC, Reporter); - Analysis.run(); -} -} // namespace clang::lifetimes diff --git a/clang/lib/Analysis/LifetimeSafety/CMakeLists.txt b/clang/lib/Analysis/LifetimeSafety/CMakeLists.txt new file mode 100644 index 0000000..8584292 --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/CMakeLists.txt @@ -0,0 +1,12 @@ +add_clang_library(clangAnalysisLifetimeSafety + Checker.cpp + Facts.cpp + FactsGenerator.cpp + LifetimeAnnotations.cpp + LifetimeSafety.cpp + LiveOrigins.cpp + Loans.cpp + LoanPropagation.cpp + Origins.cpp + ) + diff --git a/clang/lib/Analysis/LifetimeSafety/Checker.cpp b/clang/lib/Analysis/LifetimeSafety/Checker.cpp new file mode 100644 index 0000000..c443c3a --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/Checker.cpp @@ -0,0 +1,130 @@ +//===- Checker.cpp - C++ Lifetime Safety Checker ----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file implements the LifetimeChecker, which detects use-after-free +// errors by checking if live origins hold loans that have expired. +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety/Checker.h" +#include "clang/AST/Expr.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Loans.h" +#include "clang/Analysis/Analyses/PostOrderCFGView.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/TimeProfiler.h" + +namespace clang::lifetimes::internal { + +static Confidence livenessKindToConfidence(LivenessKind K) { + switch (K) { + case LivenessKind::Must: + return Confidence::Definite; + case LivenessKind::Maybe: + return Confidence::Maybe; + case LivenessKind::Dead: + return Confidence::None; + } + llvm_unreachable("unknown liveness kind"); +} + +namespace { + +/// Struct to store the complete context for a potential lifetime violation. +struct PendingWarning { + SourceLocation ExpiryLoc; // Where the loan expired. + const Expr *UseExpr; // Where the origin holding this loan was used. + Confidence ConfidenceLevel; +}; + +class LifetimeChecker { +private: + llvm::DenseMap<LoanID, PendingWarning> FinalWarningsMap; + const LoanPropagationAnalysis &LoanPropagation; + const LiveOriginsAnalysis &LiveOrigins; + const FactManager &FactMgr; + LifetimeSafetyReporter *Reporter; + +public: + LifetimeChecker(const LoanPropagationAnalysis &LoanPropagation, + const LiveOriginsAnalysis &LiveOrigins, const FactManager &FM, + AnalysisDeclContext &ADC, LifetimeSafetyReporter *Reporter) + : LoanPropagation(LoanPropagation), LiveOrigins(LiveOrigins), FactMgr(FM), + Reporter(Reporter) { + for (const CFGBlock *B : *ADC.getAnalysis<PostOrderCFGView>()) + for (const Fact *F : FactMgr.getFacts(B)) + if (const auto *EF = F->getAs<ExpireFact>()) + checkExpiry(EF); + issuePendingWarnings(); + } + + /// Checks for use-after-free errors when a loan expires. + /// + /// This method examines all live origins at the expiry point and determines + /// if any of them hold the expiring loan. If so, it creates a pending + /// warning with the appropriate confidence level based on the liveness + /// information. The confidence reflects whether the origin is definitely + /// or maybe live at this point. + /// + /// Note: This implementation considers only the confidence of origin + /// liveness. Future enhancements could also consider the confidence of loan + /// propagation (e.g., a loan may only be held on some execution paths). + void checkExpiry(const ExpireFact *EF) { + LoanID ExpiredLoan = EF->getLoanID(); + LivenessMap Origins = LiveOrigins.getLiveOriginsAt(EF); + Confidence CurConfidence = Confidence::None; + const UseFact *BadUse = nullptr; + for (auto &[OID, LiveInfo] : Origins) { + LoanSet HeldLoans = LoanPropagation.getLoans(OID, EF); + if (!HeldLoans.contains(ExpiredLoan)) + continue; + // Loan is defaulted. + Confidence NewConfidence = livenessKindToConfidence(LiveInfo.Kind); + if (CurConfidence < NewConfidence) { + CurConfidence = NewConfidence; + BadUse = LiveInfo.CausingUseFact; + } + } + if (!BadUse) + return; + // We have a use-after-free. + Confidence LastConf = FinalWarningsMap.lookup(ExpiredLoan).ConfidenceLevel; + if (LastConf >= CurConfidence) + return; + FinalWarningsMap[ExpiredLoan] = {/*ExpiryLoc=*/EF->getExpiryLoc(), + /*UseExpr=*/BadUse->getUseExpr(), + /*ConfidenceLevel=*/CurConfidence}; + } + + void issuePendingWarnings() { + if (!Reporter) + return; + for (const auto &[LID, Warning] : FinalWarningsMap) { + const Loan &L = FactMgr.getLoanMgr().getLoan(LID); + const Expr *IssueExpr = L.IssueExpr; + Reporter->reportUseAfterFree(IssueExpr, Warning.UseExpr, + Warning.ExpiryLoc, Warning.ConfidenceLevel); + } + } +}; +} // namespace + +void runLifetimeChecker(const LoanPropagationAnalysis &LP, + const LiveOriginsAnalysis &LO, + const FactManager &FactMgr, AnalysisDeclContext &ADC, + LifetimeSafetyReporter *Reporter) { + llvm::TimeTraceScope TimeProfile("LifetimeChecker"); + LifetimeChecker Checker(LP, LO, FactMgr, ADC, Reporter); +} + +} // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/LifetimeSafety/Dataflow.h b/clang/lib/Analysis/LifetimeSafety/Dataflow.h new file mode 100644 index 0000000..2f7bcb6 --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/Dataflow.h @@ -0,0 +1,188 @@ +//===- Dataflow.h - Generic Dataflow Analysis Framework --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines a generic, policy-based driver for dataflow analyses. +// It provides a flexible framework that combines the dataflow runner and +// transfer functions, allowing derived classes to implement specific analyses +// by defining their lattice, join, and transfer functions. +// +//===----------------------------------------------------------------------===// +#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_DATAFLOW_H +#define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_DATAFLOW_H + +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "clang/Analysis/FlowSensitive/DataflowWorklist.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/TimeProfiler.h" +#include <optional> + +namespace clang::lifetimes::internal { + +enum class Direction { Forward, Backward }; + +/// A `ProgramPoint` identifies a location in the CFG by pointing to a specific +/// `Fact`. identified by a lifetime-related event (`Fact`). +/// +/// A `ProgramPoint` has "after" semantics: it represents the location +/// immediately after its corresponding `Fact`. +using ProgramPoint = const Fact *; + +/// A generic, policy-based driver for dataflow analyses. It combines +/// the dataflow runner and the transferer logic into a single class hierarchy. +/// +/// The derived class is expected to provide: +/// - A `Lattice` type. +/// - `StringRef getAnalysisName() const` +/// - `Lattice getInitialState();` The initial state of the analysis. +/// - `Lattice join(Lattice, Lattice);` Merges states from multiple CFG paths. +/// - `Lattice transfer(Lattice, const FactType&);` Defines how a single +/// lifetime-relevant `Fact` transforms the lattice state. Only overloads +/// for facts relevant to the analysis need to be implemented. +/// +/// \tparam Derived The CRTP derived class that implements the specific +/// analysis. +/// \tparam LatticeType The dataflow lattice used by the analysis. +/// \tparam Dir The direction of the analysis (Forward or Backward). +/// TODO: Maybe use the dataflow framework! The framework might need changes +/// to support the current comparison done at block-entry. +template <typename Derived, typename LatticeType, Direction Dir> +class DataflowAnalysis { +public: + using Lattice = LatticeType; + using Base = DataflowAnalysis<Derived, Lattice, Dir>; + +private: + const CFG &Cfg; + AnalysisDeclContext &AC; + + /// The dataflow state before a basic block is processed. + llvm::DenseMap<const CFGBlock *, Lattice> InStates; + /// The dataflow state after a basic block is processed. + llvm::DenseMap<const CFGBlock *, Lattice> OutStates; + /// The dataflow state at a Program Point. + /// In a forward analysis, this is the state after the Fact at that point has + /// been applied, while in a backward analysis, it is the state before. + llvm::DenseMap<ProgramPoint, Lattice> PerPointStates; + + static constexpr bool isForward() { return Dir == Direction::Forward; } + +protected: + FactManager &FactMgr; + + explicit DataflowAnalysis(const CFG &Cfg, AnalysisDeclContext &AC, + FactManager &FactMgr) + : Cfg(Cfg), AC(AC), FactMgr(FactMgr) {} + +public: + void run() { + Derived &D = static_cast<Derived &>(*this); + llvm::TimeTraceScope Time(D.getAnalysisName()); + + using Worklist = + std::conditional_t<Dir == Direction::Forward, ForwardDataflowWorklist, + BackwardDataflowWorklist>; + Worklist W(Cfg, AC); + + const CFGBlock *Start = isForward() ? &Cfg.getEntry() : &Cfg.getExit(); + InStates[Start] = D.getInitialState(); + W.enqueueBlock(Start); + + while (const CFGBlock *B = W.dequeue()) { + Lattice StateIn = *getInState(B); + Lattice StateOut = transferBlock(B, StateIn); + OutStates[B] = StateOut; + for (const CFGBlock *AdjacentB : isForward() ? B->succs() : B->preds()) { + if (!AdjacentB) + continue; + std::optional<Lattice> OldInState = getInState(AdjacentB); + Lattice NewInState = + !OldInState ? StateOut : D.join(*OldInState, StateOut); + // Enqueue the adjacent block if its in-state has changed or if we have + // never seen it. + if (!OldInState || NewInState != *OldInState) { + InStates[AdjacentB] = NewInState; + W.enqueueBlock(AdjacentB); + } + } + } + } + +protected: + Lattice getState(ProgramPoint P) const { return PerPointStates.lookup(P); } + + std::optional<Lattice> getInState(const CFGBlock *B) const { + auto It = InStates.find(B); + if (It == InStates.end()) + return std::nullopt; + return It->second; + } + + Lattice getOutState(const CFGBlock *B) const { return OutStates.lookup(B); } + + void dump() const { + const Derived *D = static_cast<const Derived *>(this); + llvm::dbgs() << "==========================================\n"; + llvm::dbgs() << D->getAnalysisName() << " results:\n"; + llvm::dbgs() << "==========================================\n"; + const CFGBlock &B = isForward() ? Cfg.getExit() : Cfg.getEntry(); + getOutState(&B).dump(llvm::dbgs()); + } + +private: + /// Computes the state at one end of a block by applying all its facts + /// sequentially to a given state from the other end. + Lattice transferBlock(const CFGBlock *Block, Lattice State) { + auto Facts = FactMgr.getFacts(Block); + if constexpr (isForward()) { + for (const Fact *F : Facts) { + State = transferFact(State, F); + PerPointStates[F] = State; + } + } else { + for (const Fact *F : llvm::reverse(Facts)) { + // In backward analysis, capture the state before applying the fact. + PerPointStates[F] = State; + State = transferFact(State, F); + } + } + return State; + } + + Lattice transferFact(Lattice In, const Fact *F) { + assert(F); + Derived *D = static_cast<Derived *>(this); + switch (F->getKind()) { + case Fact::Kind::Issue: + return D->transfer(In, *F->getAs<IssueFact>()); + case Fact::Kind::Expire: + return D->transfer(In, *F->getAs<ExpireFact>()); + case Fact::Kind::OriginFlow: + return D->transfer(In, *F->getAs<OriginFlowFact>()); + case Fact::Kind::ReturnOfOrigin: + return D->transfer(In, *F->getAs<ReturnOfOriginFact>()); + case Fact::Kind::Use: + return D->transfer(In, *F->getAs<UseFact>()); + case Fact::Kind::TestPoint: + return D->transfer(In, *F->getAs<TestPointFact>()); + } + llvm_unreachable("Unknown fact kind"); + } + +public: + Lattice transfer(Lattice In, const IssueFact &) { return In; } + Lattice transfer(Lattice In, const ExpireFact &) { return In; } + Lattice transfer(Lattice In, const OriginFlowFact &) { return In; } + Lattice transfer(Lattice In, const ReturnOfOriginFact &) { return In; } + Lattice transfer(Lattice In, const UseFact &) { return In; } + Lattice transfer(Lattice In, const TestPointFact &) { return In; } +}; +} // namespace clang::lifetimes::internal +#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_DATAFLOW_H diff --git a/clang/lib/Analysis/LifetimeSafety/Facts.cpp b/clang/lib/Analysis/LifetimeSafety/Facts.cpp new file mode 100644 index 0000000..1aea64f --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/Facts.cpp @@ -0,0 +1,102 @@ +//===- Facts.cpp - Lifetime Analysis Facts Implementation -------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/AST/Decl.h" +#include "clang/Analysis/Analyses/PostOrderCFGView.h" + +namespace clang::lifetimes::internal { + +void Fact::dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &) const { + OS << "Fact (Kind: " << static_cast<int>(K) << ")\n"; +} + +void IssueFact::dump(llvm::raw_ostream &OS, const LoanManager &LM, + const OriginManager &OM) const { + OS << "Issue ("; + LM.getLoan(getLoanID()).dump(OS); + OS << ", ToOrigin: "; + OM.dump(getOriginID(), OS); + OS << ")\n"; +} + +void ExpireFact::dump(llvm::raw_ostream &OS, const LoanManager &LM, + const OriginManager &) const { + OS << "Expire ("; + LM.getLoan(getLoanID()).dump(OS); + OS << ")\n"; +} + +void OriginFlowFact::dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &OM) const { + OS << "OriginFlow (Dest: "; + OM.dump(getDestOriginID(), OS); + OS << ", Src: "; + OM.dump(getSrcOriginID(), OS); + OS << (getKillDest() ? "" : ", Merge"); + OS << ")\n"; +} + +void ReturnOfOriginFact::dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &OM) const { + OS << "ReturnOfOrigin ("; + OM.dump(getReturnedOriginID(), OS); + OS << ")\n"; +} + +void UseFact::dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &OM) const { + OS << "Use ("; + OM.dump(getUsedOrigin(OM), OS); + OS << ", " << (isWritten() ? "Write" : "Read") << ")\n"; +} + +void TestPointFact::dump(llvm::raw_ostream &OS, const LoanManager &, + const OriginManager &) const { + OS << "TestPoint (Annotation: \"" << getAnnotation() << "\")\n"; +} + +llvm::StringMap<ProgramPoint> FactManager::getTestPoints() const { + llvm::StringMap<ProgramPoint> AnnotationToPointMap; + for (const CFGBlock *Block : BlockToFactsMap.keys()) { + for (const Fact *F : getFacts(Block)) { + if (const auto *TPF = F->getAs<TestPointFact>()) { + StringRef PointName = TPF->getAnnotation(); + assert(AnnotationToPointMap.find(PointName) == + AnnotationToPointMap.end() && + "more than one test points with the same name"); + AnnotationToPointMap[PointName] = F; + } + } + } + return AnnotationToPointMap; +} + +void FactManager::dump(const CFG &Cfg, AnalysisDeclContext &AC) const { + llvm::dbgs() << "==========================================\n"; + llvm::dbgs() << " Lifetime Analysis Facts:\n"; + llvm::dbgs() << "==========================================\n"; + if (const Decl *D = AC.getDecl()) + if (const auto *ND = dyn_cast<NamedDecl>(D)) + llvm::dbgs() << "Function: " << ND->getQualifiedNameAsString() << "\n"; + // Print blocks in the order as they appear in code for a stable ordering. + for (const CFGBlock *B : *AC.getAnalysis<PostOrderCFGView>()) { + llvm::dbgs() << " Block B" << B->getBlockID() << ":\n"; + auto It = BlockToFactsMap.find(B); + if (It != BlockToFactsMap.end()) { + for (const Fact *F : It->second) { + llvm::dbgs() << " "; + F->dump(llvm::dbgs(), LoanMgr, OriginMgr); + } + } + llvm::dbgs() << " End of Block\n"; + } +} + +} // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp b/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp new file mode 100644 index 0000000..485308f --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp @@ -0,0 +1,348 @@ +//===- FactsGenerator.cpp - Lifetime Facts Generation -----------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety/FactsGenerator.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h" +#include "clang/Analysis/Analyses/PostOrderCFGView.h" +#include "llvm/Support/TimeProfiler.h" + +namespace clang::lifetimes::internal { + +static bool isGslPointerType(QualType QT) { + if (const auto *RD = QT->getAsCXXRecordDecl()) { + // We need to check the template definition for specializations. + if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) + return CTSD->getSpecializedTemplate() + ->getTemplatedDecl() + ->hasAttr<PointerAttr>(); + return RD->hasAttr<PointerAttr>(); + } + return false; +} + +static bool isPointerType(QualType QT) { + return QT->isPointerOrReferenceType() || isGslPointerType(QT); +} +// Check if a type has an origin. +static bool hasOrigin(const Expr *E) { + return E->isGLValue() || isPointerType(E->getType()); +} + +static bool hasOrigin(const VarDecl *VD) { + return isPointerType(VD->getType()); +} + +/// Creates a loan for the storage path of a given declaration reference. +/// This function should be called whenever a DeclRefExpr represents a borrow. +/// \param DRE The declaration reference expression that initiates the borrow. +/// \return The new Loan on success, nullptr otherwise. +static const Loan *createLoan(FactManager &FactMgr, const DeclRefExpr *DRE) { + if (const auto *VD = dyn_cast<ValueDecl>(DRE->getDecl())) { + AccessPath Path(VD); + // The loan is created at the location of the DeclRefExpr. + return &FactMgr.getLoanMgr().addLoan(Path, DRE); + } + return nullptr; +} + +void FactsGenerator::run() { + llvm::TimeTraceScope TimeProfile("FactGenerator"); + // Iterate through the CFG blocks in reverse post-order to ensure that + // initializations and destructions are processed in the correct sequence. + for (const CFGBlock *Block : *AC.getAnalysis<PostOrderCFGView>()) { + CurrentBlockFacts.clear(); + for (unsigned I = 0; I < Block->size(); ++I) { + const CFGElement &Element = Block->Elements[I]; + if (std::optional<CFGStmt> CS = Element.getAs<CFGStmt>()) + Visit(CS->getStmt()); + else if (std::optional<CFGAutomaticObjDtor> DtorOpt = + Element.getAs<CFGAutomaticObjDtor>()) + handleDestructor(*DtorOpt); + } + FactMgr.addBlockFacts(Block, CurrentBlockFacts); + } +} + +void FactsGenerator::VisitDeclStmt(const DeclStmt *DS) { + for (const Decl *D : DS->decls()) + if (const auto *VD = dyn_cast<VarDecl>(D)) + if (hasOrigin(VD)) + if (const Expr *InitExpr = VD->getInit()) + killAndFlowOrigin(*VD, *InitExpr); +} + +void FactsGenerator::VisitDeclRefExpr(const DeclRefExpr *DRE) { + handleUse(DRE); + // For non-pointer/non-view types, a reference to the variable's storage + // is a borrow. We create a loan for it. + // For pointer/view types, we stick to the existing model for now and do + // not create an extra origin for the l-value expression itself. + + // TODO: A single origin for a `DeclRefExpr` for a pointer or view type is + // not sufficient to model the different levels of indirection. The current + // single-origin model cannot distinguish between a loan to the variable's + // storage and a loan to what it points to. A multi-origin model would be + // required for this. + if (!isPointerType(DRE->getType())) { + if (const Loan *L = createLoan(FactMgr, DRE)) { + OriginID ExprOID = FactMgr.getOriginMgr().getOrCreate(*DRE); + CurrentBlockFacts.push_back( + FactMgr.createFact<IssueFact>(L->ID, ExprOID)); + } + } +} + +void FactsGenerator::VisitCXXConstructExpr(const CXXConstructExpr *CCE) { + if (isGslPointerType(CCE->getType())) { + handleGSLPointerConstruction(CCE); + return; + } +} + +void FactsGenerator::VisitCXXMemberCallExpr(const CXXMemberCallExpr *MCE) { + // Specifically for conversion operators, + // like `std::string_view p = std::string{};` + if (isGslPointerType(MCE->getType()) && + isa<CXXConversionDecl>(MCE->getCalleeDecl())) { + // The argument is the implicit object itself. + handleFunctionCall(MCE, MCE->getMethodDecl(), + {MCE->getImplicitObjectArgument()}, + /*IsGslConstruction=*/true); + } + if (const CXXMethodDecl *Method = MCE->getMethodDecl()) { + // Construct the argument list, with the implicit 'this' object as the + // first argument. + llvm::SmallVector<const Expr *, 4> Args; + Args.push_back(MCE->getImplicitObjectArgument()); + Args.append(MCE->getArgs(), MCE->getArgs() + MCE->getNumArgs()); + + handleFunctionCall(MCE, Method, Args, /*IsGslConstruction=*/false); + } +} + +void FactsGenerator::VisitCallExpr(const CallExpr *CE) { + handleFunctionCall(CE, CE->getDirectCallee(), + {CE->getArgs(), CE->getNumArgs()}); +} + +void FactsGenerator::VisitCXXNullPtrLiteralExpr( + const CXXNullPtrLiteralExpr *N) { + /// TODO: Handle nullptr expr as a special 'null' loan. Uninitialized + /// pointers can use the same type of loan. + FactMgr.getOriginMgr().getOrCreate(*N); +} + +void FactsGenerator::VisitImplicitCastExpr(const ImplicitCastExpr *ICE) { + if (!hasOrigin(ICE)) + return; + // An ImplicitCastExpr node itself gets an origin, which flows from the + // origin of its sub-expression (after stripping its own parens/casts). + killAndFlowOrigin(*ICE, *ICE->getSubExpr()); +} + +void FactsGenerator::VisitUnaryOperator(const UnaryOperator *UO) { + if (UO->getOpcode() == UO_AddrOf) { + const Expr *SubExpr = UO->getSubExpr(); + // Taking address of a pointer-type expression is not yet supported and + // will be supported in multi-origin model. + if (isPointerType(SubExpr->getType())) + return; + // The origin of an address-of expression (e.g., &x) is the origin of + // its sub-expression (x). This fact will cause the dataflow analysis + // to propagate any loans held by the sub-expression's origin to the + // origin of this UnaryOperator expression. + killAndFlowOrigin(*UO, *SubExpr); + } +} + +void FactsGenerator::VisitReturnStmt(const ReturnStmt *RS) { + if (const Expr *RetExpr = RS->getRetValue()) { + if (hasOrigin(RetExpr)) { + OriginID OID = FactMgr.getOriginMgr().getOrCreate(*RetExpr); + CurrentBlockFacts.push_back(FactMgr.createFact<ReturnOfOriginFact>(OID)); + } + } +} + +void FactsGenerator::VisitBinaryOperator(const BinaryOperator *BO) { + if (BO->isAssignmentOp()) + handleAssignment(BO->getLHS(), BO->getRHS()); +} + +void FactsGenerator::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *OCE) { + // Assignment operators have special "kill-then-propagate" semantics + // and are handled separately. + if (OCE->isAssignmentOp() && OCE->getNumArgs() == 2) { + handleAssignment(OCE->getArg(0), OCE->getArg(1)); + return; + } + handleFunctionCall(OCE, OCE->getDirectCallee(), + {OCE->getArgs(), OCE->getNumArgs()}, + /*IsGslConstruction=*/false); +} + +void FactsGenerator::VisitCXXFunctionalCastExpr( + const CXXFunctionalCastExpr *FCE) { + // Check if this is a test point marker. If so, we are done with this + // expression. + if (handleTestPoint(FCE)) + return; + if (isGslPointerType(FCE->getType())) + killAndFlowOrigin(*FCE, *FCE->getSubExpr()); +} + +void FactsGenerator::VisitInitListExpr(const InitListExpr *ILE) { + if (!hasOrigin(ILE)) + return; + // For list initialization with a single element, like `View{...}`, the + // origin of the list itself is the origin of its single element. + if (ILE->getNumInits() == 1) + killAndFlowOrigin(*ILE, *ILE->getInit(0)); +} + +void FactsGenerator::VisitMaterializeTemporaryExpr( + const MaterializeTemporaryExpr *MTE) { + if (!hasOrigin(MTE)) + return; + // A temporary object's origin is the same as the origin of the + // expression that initializes it. + killAndFlowOrigin(*MTE, *MTE->getSubExpr()); +} + +void FactsGenerator::handleDestructor(const CFGAutomaticObjDtor &DtorOpt) { + /// TODO: Also handle trivial destructors (e.g., for `int` + /// variables) which will never have a CFGAutomaticObjDtor node. + /// TODO: Handle loans to temporaries. + /// TODO: Consider using clang::CFG::BuildOptions::AddLifetime to reuse the + /// lifetime ends. + const VarDecl *DestructedVD = DtorOpt.getVarDecl(); + if (!DestructedVD) + return; + // Iterate through all loans to see if any expire. + /// TODO(opt): Do better than a linear search to find loans associated with + /// 'DestructedVD'. + for (const Loan &L : FactMgr.getLoanMgr().getLoans()) { + const AccessPath &LoanPath = L.Path; + // Check if the loan is for a stack variable and if that variable + // is the one being destructed. + if (LoanPath.D == DestructedVD) + CurrentBlockFacts.push_back(FactMgr.createFact<ExpireFact>( + L.ID, DtorOpt.getTriggerStmt()->getEndLoc())); + } +} + +void FactsGenerator::handleGSLPointerConstruction(const CXXConstructExpr *CCE) { + assert(isGslPointerType(CCE->getType())); + if (CCE->getNumArgs() != 1) + return; + if (hasOrigin(CCE->getArg(0))) + killAndFlowOrigin(*CCE, *CCE->getArg(0)); + else + // This could be a new borrow. + handleFunctionCall(CCE, CCE->getConstructor(), + {CCE->getArgs(), CCE->getNumArgs()}, + /*IsGslConstruction=*/true); +} + +/// Checks if a call-like expression creates a borrow by passing a value to a +/// reference parameter, creating an IssueFact if it does. +/// \param IsGslConstruction True if this is a GSL construction where all +/// argument origins should flow to the returned origin. +void FactsGenerator::handleFunctionCall(const Expr *Call, + const FunctionDecl *FD, + ArrayRef<const Expr *> Args, + bool IsGslConstruction) { + // Ignore functions returning values with no origin. + if (!FD || !hasOrigin(Call)) + return; + auto IsArgLifetimeBound = [FD](unsigned I) -> bool { + const ParmVarDecl *PVD = nullptr; + if (const auto *Method = dyn_cast<CXXMethodDecl>(FD); + Method && Method->isInstance()) { + if (I == 0) + // For the 'this' argument, the attribute is on the method itself. + return implicitObjectParamIsLifetimeBound(Method); + if ((I - 1) < Method->getNumParams()) + // For explicit arguments, find the corresponding parameter + // declaration. + PVD = Method->getParamDecl(I - 1); + } else if (I < FD->getNumParams()) + // For free functions or static methods. + PVD = FD->getParamDecl(I); + return PVD ? PVD->hasAttr<clang::LifetimeBoundAttr>() : false; + }; + if (Args.empty()) + return; + bool killedSrc = false; + for (unsigned I = 0; I < Args.size(); ++I) + if (IsGslConstruction || IsArgLifetimeBound(I)) { + if (!killedSrc) { + killedSrc = true; + killAndFlowOrigin(*Call, *Args[I]); + } else + flowOrigin(*Call, *Args[I]); + } +} + +/// Checks if the expression is a `void("__lifetime_test_point_...")` cast. +/// If so, creates a `TestPointFact` and returns true. +bool FactsGenerator::handleTestPoint(const CXXFunctionalCastExpr *FCE) { + if (!FCE->getType()->isVoidType()) + return false; + + const auto *SubExpr = FCE->getSubExpr()->IgnoreParenImpCasts(); + if (const auto *SL = dyn_cast<StringLiteral>(SubExpr)) { + llvm::StringRef LiteralValue = SL->getString(); + const std::string Prefix = "__lifetime_test_point_"; + + if (LiteralValue.starts_with(Prefix)) { + StringRef Annotation = LiteralValue.drop_front(Prefix.length()); + CurrentBlockFacts.push_back( + FactMgr.createFact<TestPointFact>(Annotation)); + return true; + } + } + return false; +} + +void FactsGenerator::handleAssignment(const Expr *LHSExpr, + const Expr *RHSExpr) { + if (!hasOrigin(LHSExpr)) + return; + // Find the underlying variable declaration for the left-hand side. + if (const auto *DRE_LHS = + dyn_cast<DeclRefExpr>(LHSExpr->IgnoreParenImpCasts())) { + markUseAsWrite(DRE_LHS); + if (const auto *VD_LHS = dyn_cast<ValueDecl>(DRE_LHS->getDecl())) { + // Kill the old loans of the destination origin and flow the new loans + // from the source origin. + killAndFlowOrigin(*VD_LHS, *RHSExpr); + } + } +} + +// A DeclRefExpr will be treated as a use of the referenced decl. It will be +// checked for use-after-free unless it is later marked as being written to +// (e.g. on the left-hand side of an assignment). +void FactsGenerator::handleUse(const DeclRefExpr *DRE) { + if (isPointerType(DRE->getType())) { + UseFact *UF = FactMgr.createFact<UseFact>(DRE); + CurrentBlockFacts.push_back(UF); + assert(!UseFacts.contains(DRE)); + UseFacts[DRE] = UF; + } +} + +void FactsGenerator::markUseAsWrite(const DeclRefExpr *DRE) { + if (!isPointerType(DRE->getType())) + return; + assert(UseFacts.contains(DRE)); + UseFacts[DRE]->markAsWritten(); +} + +} // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/LifetimeAnnotations.cpp b/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp index e791224..ad61a42 100644 --- a/clang/lib/Analysis/LifetimeAnnotations.cpp +++ b/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp @@ -5,7 +5,7 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// -#include "clang/Analysis/Analyses/LifetimeAnnotations.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" @@ -13,8 +13,7 @@ #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" -namespace clang { -namespace lifetimes { +namespace clang::lifetimes { const FunctionDecl * getDeclWithMergedLifetimeBoundAttrs(const FunctionDecl *FD) { @@ -71,5 +70,4 @@ bool implicitObjectParamIsLifetimeBound(const FunctionDecl *FD) { return isNormalAssignmentOperator(FD); } -} // namespace lifetimes -} // namespace clang +} // namespace clang::lifetimes diff --git a/clang/lib/Analysis/LifetimeSafety/LifetimeSafety.cpp b/clang/lib/Analysis/LifetimeSafety/LifetimeSafety.cpp new file mode 100644 index 0000000..00c7ed90 --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/LifetimeSafety.cpp @@ -0,0 +1,77 @@ +//===- LifetimeSafety.cpp - C++ Lifetime Safety Analysis -*--------- C++-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file implements the main LifetimeSafetyAnalysis class, which coordinates +// the various components (fact generation, loan propagation, live origins +// analysis, and checking) to detect lifetime safety violations in C++ code. +// +//===----------------------------------------------------------------------===// +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h" +#include "clang/AST/Decl.h" +#include "clang/AST/Expr.h" +#include "clang/AST/Type.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Checker.h" +#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h" +#include "clang/Analysis/Analyses/LifetimeSafety/FactsGenerator.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "llvm/ADT/FoldingSet.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/TimeProfiler.h" +#include <memory> + +namespace clang::lifetimes { +namespace internal { + +LifetimeSafetyAnalysis::LifetimeSafetyAnalysis(AnalysisDeclContext &AC, + LifetimeSafetyReporter *Reporter) + : AC(AC), Reporter(Reporter) {} + +void LifetimeSafetyAnalysis::run() { + llvm::TimeTraceScope TimeProfile("LifetimeSafetyAnalysis"); + + const CFG &Cfg = *AC.getCFG(); + DEBUG_WITH_TYPE("PrintCFG", Cfg.dump(AC.getASTContext().getLangOpts(), + /*ShowColors=*/true)); + + FactsGenerator FactGen(FactMgr, AC); + FactGen.run(); + DEBUG_WITH_TYPE("LifetimeFacts", FactMgr.dump(Cfg, AC)); + + /// TODO(opt): Consider optimizing individual blocks before running the + /// dataflow analysis. + /// 1. Expression Origins: These are assigned once and read at most once, + /// forming simple chains. These chains can be compressed into a single + /// assignment. + /// 2. Block-Local Loans: Origins of expressions are never read by other + /// blocks; only Decls are visible. Therefore, loans in a block that + /// never reach an Origin associated with a Decl can be safely dropped by + /// the analysis. + /// 3. Collapse ExpireFacts belonging to same source location into a single + /// Fact. + LoanPropagation = std::make_unique<LoanPropagationAnalysis>( + Cfg, AC, FactMgr, Factory.OriginMapFactory, Factory.LoanSetFactory); + + LiveOrigins = std::make_unique<LiveOriginsAnalysis>( + Cfg, AC, FactMgr, Factory.LivenessMapFactory); + DEBUG_WITH_TYPE("LiveOrigins", + LiveOrigins->dump(llvm::dbgs(), FactMgr.getTestPoints())); + + runLifetimeChecker(*LoanPropagation, *LiveOrigins, FactMgr, AC, Reporter); +} +} // namespace internal + +void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC, + LifetimeSafetyReporter *Reporter) { + internal::LifetimeSafetyAnalysis Analysis(AC, Reporter); + Analysis.run(); +} +} // namespace clang::lifetimes diff --git a/clang/lib/Analysis/LifetimeSafety/LiveOrigins.cpp b/clang/lib/Analysis/LifetimeSafety/LiveOrigins.cpp new file mode 100644 index 0000000..cddb3f3c --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/LiveOrigins.cpp @@ -0,0 +1,180 @@ +//===- LiveOrigins.cpp - Live Origins Analysis -----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h" +#include "Dataflow.h" +#include "llvm/Support/ErrorHandling.h" + +namespace clang::lifetimes::internal { +namespace { + +/// The dataflow lattice for origin liveness analysis. +/// It tracks which origins are live, why they're live (which UseFact), +/// and the confidence level of that liveness. +struct Lattice { + LivenessMap LiveOrigins; + + Lattice() : LiveOrigins(nullptr) {}; + + explicit Lattice(LivenessMap L) : LiveOrigins(L) {} + + bool operator==(const Lattice &Other) const { + return LiveOrigins == Other.LiveOrigins; + } + + bool operator!=(const Lattice &Other) const { return !(*this == Other); } + + void dump(llvm::raw_ostream &OS, const OriginManager &OM) const { + if (LiveOrigins.isEmpty()) + OS << " <empty>\n"; + for (const auto &Entry : LiveOrigins) { + OriginID OID = Entry.first; + const LivenessInfo &Info = Entry.second; + OS << " "; + OM.dump(OID, OS); + OS << " is "; + switch (Info.Kind) { + case LivenessKind::Must: + OS << "definitely"; + break; + case LivenessKind::Maybe: + OS << "maybe"; + break; + case LivenessKind::Dead: + llvm_unreachable("liveness kind of live origins should not be dead."); + } + OS << " live at this point\n"; + } + } +}; + +/// The analysis that tracks which origins are live, with granular information +/// about the causing use fact and confidence level. This is a backward +/// analysis. +class AnalysisImpl + : public DataflowAnalysis<AnalysisImpl, Lattice, Direction::Backward> { + +public: + AnalysisImpl(const CFG &C, AnalysisDeclContext &AC, FactManager &F, + LivenessMap::Factory &SF) + : DataflowAnalysis(C, AC, F), FactMgr(F), Factory(SF) {} + using DataflowAnalysis<AnalysisImpl, Lattice, Direction::Backward>::transfer; + + StringRef getAnalysisName() const { return "LiveOrigins"; } + + Lattice getInitialState() { return Lattice(Factory.getEmptyMap()); } + + /// Merges two lattices by combining liveness information. + /// When the same origin has different confidence levels, we take the lower + /// one. + Lattice join(Lattice L1, Lattice L2) const { + LivenessMap Merged = L1.LiveOrigins; + // Take the earliest UseFact to make the join hermetic and commutative. + auto CombineUseFact = [](const UseFact &A, + const UseFact &B) -> const UseFact * { + return A.getUseExpr()->getExprLoc() < B.getUseExpr()->getExprLoc() ? &A + : &B; + }; + auto CombineLivenessKind = [](LivenessKind K1, + LivenessKind K2) -> LivenessKind { + assert(K1 != LivenessKind::Dead && "LivenessKind should not be dead."); + assert(K2 != LivenessKind::Dead && "LivenessKind should not be dead."); + // Only return "Must" if both paths are "Must", otherwise Maybe. + if (K1 == LivenessKind::Must && K2 == LivenessKind::Must) + return LivenessKind::Must; + return LivenessKind::Maybe; + }; + auto CombineLivenessInfo = [&](const LivenessInfo *L1, + const LivenessInfo *L2) -> LivenessInfo { + assert((L1 || L2) && "unexpectedly merging 2 empty sets"); + if (!L1) + return LivenessInfo(L2->CausingUseFact, LivenessKind::Maybe); + if (!L2) + return LivenessInfo(L1->CausingUseFact, LivenessKind::Maybe); + return LivenessInfo( + CombineUseFact(*L1->CausingUseFact, *L2->CausingUseFact), + CombineLivenessKind(L1->Kind, L2->Kind)); + }; + return Lattice(utils::join( + L1.LiveOrigins, L2.LiveOrigins, Factory, CombineLivenessInfo, + // A symmetric join is required here. If an origin is live on one + // branch but not the other, its confidence must be demoted to `Maybe`. + utils::JoinKind::Symmetric)); + } + + /// A read operation makes the origin live with definite confidence, as it + /// dominates this program point. A write operation kills the liveness of + /// the origin since it overwrites the value. + Lattice transfer(Lattice In, const UseFact &UF) { + OriginID OID = UF.getUsedOrigin(FactMgr.getOriginMgr()); + // Write kills liveness. + if (UF.isWritten()) + return Lattice(Factory.remove(In.LiveOrigins, OID)); + // Read makes origin live with definite confidence (dominates this point). + return Lattice(Factory.add(In.LiveOrigins, OID, + LivenessInfo(&UF, LivenessKind::Must))); + } + + /// Issuing a new loan to an origin kills its liveness. + Lattice transfer(Lattice In, const IssueFact &IF) { + return Lattice(Factory.remove(In.LiveOrigins, IF.getOriginID())); + } + + /// An OriginFlow kills the liveness of the destination origin if `KillDest` + /// is true. Otherwise, it propagates liveness from destination to source. + Lattice transfer(Lattice In, const OriginFlowFact &OF) { + if (!OF.getKillDest()) + return In; + return Lattice(Factory.remove(In.LiveOrigins, OF.getDestOriginID())); + } + + LivenessMap getLiveOriginsAt(ProgramPoint P) const { + return getState(P).LiveOrigins; + } + + // Dump liveness values on all test points in the program. + void dump(llvm::raw_ostream &OS, + llvm::StringMap<ProgramPoint> TestPoints) const { + llvm::dbgs() << "==========================================\n"; + llvm::dbgs() << getAnalysisName() << " results:\n"; + llvm::dbgs() << "==========================================\n"; + for (const auto &Entry : TestPoints) { + OS << "TestPoint: " << Entry.getKey() << "\n"; + getState(Entry.getValue()).dump(OS, FactMgr.getOriginMgr()); + } + } + +private: + FactManager &FactMgr; + LivenessMap::Factory &Factory; +}; +} // namespace + +// PImpl wrapper implementation +class LiveOriginsAnalysis::Impl : public AnalysisImpl { + using AnalysisImpl::AnalysisImpl; +}; + +LiveOriginsAnalysis::LiveOriginsAnalysis(const CFG &C, AnalysisDeclContext &AC, + FactManager &F, + LivenessMap::Factory &SF) + : PImpl(std::make_unique<Impl>(C, AC, F, SF)) { + PImpl->run(); +} + +LiveOriginsAnalysis::~LiveOriginsAnalysis() = default; + +LivenessMap LiveOriginsAnalysis::getLiveOriginsAt(ProgramPoint P) const { + return PImpl->getLiveOriginsAt(P); +} + +void LiveOriginsAnalysis::dump(llvm::raw_ostream &OS, + llvm::StringMap<ProgramPoint> TestPoints) const { + PImpl->dump(OS, TestPoints); +} +} // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/LifetimeSafety/LoanPropagation.cpp b/clang/lib/Analysis/LifetimeSafety/LoanPropagation.cpp new file mode 100644 index 0000000..387097e --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/LoanPropagation.cpp @@ -0,0 +1,138 @@ +//===- LoanPropagation.cpp - Loan Propagation Analysis ---------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h" +#include "Dataflow.h" +#include <memory> + +namespace clang::lifetimes::internal { +namespace { +/// Represents the dataflow lattice for loan propagation. +/// +/// This lattice tracks which loans each origin may hold at a given program +/// point.The lattice has a finite height: An origin's loan set is bounded by +/// the total number of loans in the function. +/// TODO(opt): To reduce the lattice size, propagate origins of declarations, +/// not expressions, because expressions are not visible across blocks. +struct Lattice { + /// The map from an origin to the set of loans it contains. + OriginLoanMap Origins = OriginLoanMap(nullptr); + + explicit Lattice(const OriginLoanMap &S) : Origins(S) {} + Lattice() = default; + + bool operator==(const Lattice &Other) const { + return Origins == Other.Origins; + } + bool operator!=(const Lattice &Other) const { return !(*this == Other); } + + void dump(llvm::raw_ostream &OS) const { + OS << "LoanPropagationLattice State:\n"; + if (Origins.isEmpty()) + OS << " <empty>\n"; + for (const auto &Entry : Origins) { + if (Entry.second.isEmpty()) + OS << " Origin " << Entry.first << " contains no loans\n"; + for (const LoanID &LID : Entry.second) + OS << " Origin " << Entry.first << " contains Loan " << LID << "\n"; + } + } +}; + +class AnalysisImpl + : public DataflowAnalysis<AnalysisImpl, Lattice, Direction::Forward> { +public: + AnalysisImpl(const CFG &C, AnalysisDeclContext &AC, FactManager &F, + OriginLoanMap::Factory &OriginLoanMapFactory, + LoanSet::Factory &LoanSetFactory) + : DataflowAnalysis(C, AC, F), OriginLoanMapFactory(OriginLoanMapFactory), + LoanSetFactory(LoanSetFactory) {} + + using Base::transfer; + + StringRef getAnalysisName() const { return "LoanPropagation"; } + + Lattice getInitialState() { return Lattice{}; } + + /// Merges two lattices by taking the union of loans for each origin. + // TODO(opt): Keep the state small by removing origins which become dead. + Lattice join(Lattice A, Lattice B) { + OriginLoanMap JoinedOrigins = utils::join( + A.Origins, B.Origins, OriginLoanMapFactory, + [&](const LoanSet *S1, const LoanSet *S2) { + assert((S1 || S2) && "unexpectedly merging 2 empty sets"); + if (!S1) + return *S2; + if (!S2) + return *S1; + return utils::join(*S1, *S2, LoanSetFactory); + }, + // Asymmetric join is a performance win. For origins present only on one + // branch, the loan set can be carried over as-is. + utils::JoinKind::Asymmetric); + return Lattice(JoinedOrigins); + } + + /// A new loan is issued to the origin. Old loans are erased. + Lattice transfer(Lattice In, const IssueFact &F) { + OriginID OID = F.getOriginID(); + LoanID LID = F.getLoanID(); + return Lattice(OriginLoanMapFactory.add( + In.Origins, OID, + LoanSetFactory.add(LoanSetFactory.getEmptySet(), LID))); + } + + /// A flow from source to destination. If `KillDest` is true, this replaces + /// the destination's loans with the source's. Otherwise, the source's loans + /// are merged into the destination's. + Lattice transfer(Lattice In, const OriginFlowFact &F) { + OriginID DestOID = F.getDestOriginID(); + OriginID SrcOID = F.getSrcOriginID(); + + LoanSet DestLoans = + F.getKillDest() ? LoanSetFactory.getEmptySet() : getLoans(In, DestOID); + LoanSet SrcLoans = getLoans(In, SrcOID); + LoanSet MergedLoans = utils::join(DestLoans, SrcLoans, LoanSetFactory); + + return Lattice(OriginLoanMapFactory.add(In.Origins, DestOID, MergedLoans)); + } + + LoanSet getLoans(OriginID OID, ProgramPoint P) const { + return getLoans(getState(P), OID); + } + +private: + LoanSet getLoans(Lattice L, OriginID OID) const { + if (auto *Loans = L.Origins.lookup(OID)) + return *Loans; + return LoanSetFactory.getEmptySet(); + } + + OriginLoanMap::Factory &OriginLoanMapFactory; + LoanSet::Factory &LoanSetFactory; +}; +} // namespace + +class LoanPropagationAnalysis::Impl final : public AnalysisImpl { + using AnalysisImpl::AnalysisImpl; +}; + +LoanPropagationAnalysis::LoanPropagationAnalysis( + const CFG &C, AnalysisDeclContext &AC, FactManager &F, + OriginLoanMap::Factory &OriginLoanMapFactory, + LoanSet::Factory &LoanSetFactory) + : PImpl(std::make_unique<Impl>(C, AC, F, OriginLoanMapFactory, + LoanSetFactory)) { + PImpl->run(); +} + +LoanPropagationAnalysis::~LoanPropagationAnalysis() = default; + +LoanSet LoanPropagationAnalysis::getLoans(OriginID OID, ProgramPoint P) const { + return PImpl->getLoans(OID, P); +} +} // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/LifetimeSafety/Loans.cpp b/clang/lib/Analysis/LifetimeSafety/Loans.cpp new file mode 100644 index 0000000..2c85a3c --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/Loans.cpp @@ -0,0 +1,18 @@ +//===- Loans.cpp - Loan Implementation --------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety/Loans.h" + +namespace clang::lifetimes::internal { + +void Loan::dump(llvm::raw_ostream &OS) const { + OS << ID << " (Path: "; + OS << Path.D->getNameAsString() << ")"; +} + +} // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/LifetimeSafety/Origins.cpp b/clang/lib/Analysis/LifetimeSafety/Origins.cpp new file mode 100644 index 0000000..ea51a75 --- /dev/null +++ b/clang/lib/Analysis/LifetimeSafety/Origins.cpp @@ -0,0 +1,89 @@ +//===- Origins.cpp - Origin Implementation -----------------------*- C++-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety/Origins.h" + +namespace clang::lifetimes::internal { + +void OriginManager::dump(OriginID OID, llvm::raw_ostream &OS) const { + OS << OID << " ("; + Origin O = getOrigin(OID); + if (const ValueDecl *VD = O.getDecl()) + OS << "Decl: " << VD->getNameAsString(); + else if (const Expr *E = O.getExpr()) + OS << "Expr: " << E->getStmtClassName(); + else + OS << "Unknown"; + OS << ")"; +} + +Origin &OriginManager::addOrigin(OriginID ID, const clang::ValueDecl &D) { + AllOrigins.emplace_back(ID, &D); + return AllOrigins.back(); +} + +Origin &OriginManager::addOrigin(OriginID ID, const clang::Expr &E) { + AllOrigins.emplace_back(ID, &E); + return AllOrigins.back(); +} + +// TODO: Mark this method as const once we remove the call to getOrCreate. +OriginID OriginManager::get(const Expr &E) { + auto It = ExprToOriginID.find(&E); + if (It != ExprToOriginID.end()) + return It->second; + // If the expression itself has no specific origin, and it's a reference + // to a declaration, its origin is that of the declaration it refers to. + // For pointer types, where we don't pre-emptively create an origin for the + // DeclRefExpr itself. + if (const auto *DRE = dyn_cast<DeclRefExpr>(&E)) + return get(*DRE->getDecl()); + // TODO: This should be an assert(It != ExprToOriginID.end()). The current + // implementation falls back to getOrCreate to avoid crashing on + // yet-unhandled pointer expressions, creating an empty origin for them. + return getOrCreate(E); +} + +OriginID OriginManager::get(const ValueDecl &D) { + auto It = DeclToOriginID.find(&D); + // TODO: This should be an assert(It != DeclToOriginID.end()). The current + // implementation falls back to getOrCreate to avoid crashing on + // yet-unhandled pointer expressions, creating an empty origin for them. + if (It == DeclToOriginID.end()) + return getOrCreate(D); + + return It->second; +} + +OriginID OriginManager::getOrCreate(const Expr &E) { + auto It = ExprToOriginID.find(&E); + if (It != ExprToOriginID.end()) + return It->second; + + OriginID NewID = getNextOriginID(); + addOrigin(NewID, E); + ExprToOriginID[&E] = NewID; + return NewID; +} + +const Origin &OriginManager::getOrigin(OriginID ID) const { + assert(ID.Value < AllOrigins.size()); + return AllOrigins[ID.Value]; +} + +OriginID OriginManager::getOrCreate(const ValueDecl &D) { + auto It = DeclToOriginID.find(&D); + if (It != DeclToOriginID.end()) + return It->second; + OriginID NewID = getNextOriginID(); + addOrigin(NewID, D); + DeclToOriginID[&D] = NewID; + return NewID; +} + +} // namespace clang::lifetimes::internal diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index c5371e4..df28641 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -2012,13 +2012,6 @@ static void getTrivialDefaultFunctionAttributes( FuncAttrs.addAttribute("no-infs-fp-math", "true"); if (LangOpts.NoHonorNaNs) FuncAttrs.addAttribute("no-nans-fp-math", "true"); - if (LangOpts.AllowFPReassoc && LangOpts.AllowRecip && - LangOpts.NoSignedZero && LangOpts.ApproxFunc && - (LangOpts.getDefaultFPContractMode() == - LangOptions::FPModeKind::FPM_Fast || - LangOpts.getDefaultFPContractMode() == - LangOptions::FPModeKind::FPM_FastHonorPragmas)) - FuncAttrs.addAttribute("unsafe-fp-math", "true"); if (CodeGenOpts.SoftFloat) FuncAttrs.addAttribute("use-soft-float", "true"); FuncAttrs.addAttribute("stack-protector-buffer-size", diff --git a/clang/lib/CodeGen/CGCall.h b/clang/lib/CodeGen/CGCall.h index 935b508..1ef8a3f 100644 --- a/clang/lib/CodeGen/CGCall.h +++ b/clang/lib/CodeGen/CGCall.h @@ -410,10 +410,10 @@ public: /// This is useful for adding attrs to bitcode modules that you want to link /// with but don't control, such as CUDA's libdevice. When linking with such /// a bitcode library, you might want to set e.g. its functions' -/// "unsafe-fp-math" attribute to match the attr of the functions you're +/// "denormal-fp-math" attribute to match the attr of the functions you're /// codegen'ing. Otherwise, LLVM will interpret the bitcode module's lack of -/// unsafe-fp-math attrs as tantamount to unsafe-fp-math=false, and then LLVM -/// will propagate unsafe-fp-math=false up to every transitive caller of a +/// denormal-fp-math attrs as tantamount to denormal-fp-math=ieee, and then LLVM +/// will propagate denormal-fp-math=ieee up to every transitive caller of a /// function in the bitcode library! /// /// With the exception of fast-math attrs, this will only make the attributes diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index acf8de4..8862853 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -183,11 +183,6 @@ void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(FPOptions FPFeatures) { mergeFnAttrValue("no-infs-fp-math", FPFeatures.getNoHonorInfs()); mergeFnAttrValue("no-nans-fp-math", FPFeatures.getNoHonorNaNs()); mergeFnAttrValue("no-signed-zeros-fp-math", FPFeatures.getNoSignedZero()); - mergeFnAttrValue( - "unsafe-fp-math", - FPFeatures.getAllowFPReassociate() && FPFeatures.getAllowReciprocal() && - FPFeatures.getAllowApproxFunc() && FPFeatures.getNoSignedZero() && - FPFeatures.allowFPContractAcrossStatement()); } CodeGenFunction::CGFPOptionsRAII::~CGFPOptionsRAII() { diff --git a/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp b/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp index 6596ec0..5049a0a 100644 --- a/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp +++ b/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp @@ -11,8 +11,11 @@ //===----------------------------------------------------------------------===// #include "CGBuiltin.h" +#include "CodeGenFunction.h" #include "clang/Basic/TargetBuiltins.h" +#include "clang/Frontend/FrontendDiagnostic.h" #include "llvm/Analysis/ValueTracking.h" +#include "llvm/CodeGen/MachineFunction.h" #include "llvm/IR/IntrinsicsAMDGPU.h" #include "llvm/IR/IntrinsicsR600.h" #include "llvm/IR/MemoryModelRelaxationAnnotations.h" @@ -181,6 +184,74 @@ static Value *EmitAMDGCNBallotForExec(CodeGenFunction &CGF, const CallExpr *E, return Call; } +static llvm::Value *loadTextureDescPtorAsVec8I32(CodeGenFunction &CGF, + llvm::Value *RsrcPtr) { + auto &B = CGF.Builder; + auto *VecTy = llvm::FixedVectorType::get(B.getInt32Ty(), 8); + + if (RsrcPtr->getType() == VecTy) + return RsrcPtr; + + if (RsrcPtr->getType()->isIntegerTy(32)) { + llvm::PointerType *VecPtrTy = + llvm::PointerType::get(CGF.getLLVMContext(), 8); + llvm::Value *Ptr = B.CreateIntToPtr(RsrcPtr, VecPtrTy, "tex.rsrc.from.int"); + return B.CreateAlignedLoad(VecTy, Ptr, llvm::Align(32), "tex.rsrc.val"); + } + + if (RsrcPtr->getType()->isPointerTy()) { + auto *VecPtrTy = llvm::PointerType::get( + CGF.getLLVMContext(), RsrcPtr->getType()->getPointerAddressSpace()); + llvm::Value *Typed = B.CreateBitCast(RsrcPtr, VecPtrTy, "tex.rsrc.typed"); + return B.CreateAlignedLoad(VecTy, Typed, llvm::Align(32), "tex.rsrc.val"); + } + + const auto &DL = CGF.CGM.getDataLayout(); + if (DL.getTypeSizeInBits(RsrcPtr->getType()) == 256) + return B.CreateBitCast(RsrcPtr, VecTy, "tex.rsrc.val"); + + llvm::report_fatal_error("Unexpected texture resource argument form"); +} + +llvm::CallInst * +emitAMDGCNImageOverloadedReturnType(clang::CodeGen::CodeGenFunction &CGF, + const clang::CallExpr *E, + unsigned IntrinsicID, bool IsImageStore) { + auto findTextureDescIndex = [&CGF](const CallExpr *E) -> unsigned { + QualType TexQT = CGF.getContext().AMDGPUTextureTy; + for (unsigned I = 0, N = E->getNumArgs(); I < N; ++I) { + QualType ArgTy = E->getArg(I)->getType(); + if (ArgTy == TexQT) { + return I; + } + + if (ArgTy.getCanonicalType() == TexQT.getCanonicalType()) { + return I; + } + } + + return ~0U; + }; + + clang::SmallVector<llvm::Value *, 10> Args; + unsigned RsrcIndex = findTextureDescIndex(E); + + if (RsrcIndex == ~0U) { + llvm::report_fatal_error("Invalid argument count for image builtin"); + } + + for (unsigned I = 0; I < E->getNumArgs(); ++I) { + llvm::Value *V = CGF.EmitScalarExpr(E->getArg(I)); + if (I == RsrcIndex) + V = loadTextureDescPtorAsVec8I32(CGF, V); + Args.push_back(V); + } + + llvm::Type *RetTy = IsImageStore ? CGF.VoidTy : CGF.ConvertType(E->getType()); + llvm::CallInst *Call = CGF.Builder.CreateIntrinsic(RetTy, IntrinsicID, Args); + return Call; +} + // Emit an intrinsic that has 1 float or double operand, and 1 integer. static Value *emitFPIntBuiltin(CodeGenFunction &CGF, const CallExpr *E, @@ -937,6 +1008,136 @@ Value *CodeGenFunction::EmitAMDGPUBuiltinExpr(unsigned BuiltinID, return Builder.CreateInsertElement(I0, A, 1); } + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_1d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_1darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_2d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_2darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_3d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_cube, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_1d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_1darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_2d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_2darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_3d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_cube, false); + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_1d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_1darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_2d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_2darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_3d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_cube, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_1d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_1darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_2d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_2darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_3d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_cube, true); + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_1d, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_1darray, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_2d, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_2darray, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_3d, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_cube, false); case AMDGPU::BI__builtin_amdgcn_mfma_scale_f32_16x16x128_f8f6f4: case AMDGPU::BI__builtin_amdgcn_mfma_scale_f32_32x32x64_f8f6f4: { llvm::FixedVectorType *VT = FixedVectorType::get(Builder.getInt32Ty(), 8); diff --git a/clang/lib/Driver/Distro.cpp b/clang/lib/Driver/Distro.cpp index 90e5a39..8a5a9fc 100644 --- a/clang/lib/Driver/Distro.cpp +++ b/clang/lib/Driver/Distro.cpp @@ -61,11 +61,6 @@ static Distro::DistroType DetectLsbRelease(llvm::vfs::FileSystem &VFS) { if (Version == Distro::UnknownDistro && Line.starts_with("DISTRIB_CODENAME=")) Version = llvm::StringSwitch<Distro::DistroType>(Line.substr(17)) - .Case("hardy", Distro::UbuntuHardy) - .Case("intrepid", Distro::UbuntuIntrepid) - .Case("jaunty", Distro::UbuntuJaunty) - .Case("karmic", Distro::UbuntuKarmic) - .Case("lucid", Distro::UbuntuLucid) .Case("maverick", Distro::UbuntuMaverick) .Case("natty", Distro::UbuntuNatty) .Case("oneiric", Distro::UbuntuOneiric) diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp index 16e35b0..8eb4d34e 100644 --- a/clang/lib/Driver/ToolChains/Linux.cpp +++ b/clang/lib/Driver/ToolChains/Linux.cpp @@ -301,11 +301,10 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS // ABI requires a mapping between the GOT and the symbol table. // Android loader does not support .gnu.hash until API 23. - // Hexagon linker/loader does not support .gnu.hash + // Hexagon linker/loader does not support .gnu.hash. + // SUSE SLES 11 will stop being supported Mar 2028. if (!IsMips && !IsHexagon) { - if (Distro.IsOpenSUSE() || Distro == Distro::UbuntuLucid || - Distro == Distro::UbuntuJaunty || Distro == Distro::UbuntuKarmic || - (IsAndroid && Triple.isAndroidVersionLT(23))) + if (Distro.IsOpenSUSE() || (IsAndroid && Triple.isAndroidVersionLT(23))) ExtraOpts.push_back("--hash-style=both"); else ExtraOpts.push_back("--hash-style=gnu"); diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp index d6cd7eb..e4b158e 100644 --- a/clang/lib/Parse/ParseDecl.cpp +++ b/clang/lib/Parse/ParseDecl.cpp @@ -1934,12 +1934,12 @@ Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration( bool RequireSemi, ForRangeInit *FRI, SourceLocation *DeclSpecStart) { // Need to retain these for diagnostics before we add them to the DeclSepc. ParsedAttributesView OriginalDeclSpecAttrs; - OriginalDeclSpecAttrs.addAll(DeclSpecAttrs.begin(), DeclSpecAttrs.end()); + OriginalDeclSpecAttrs.prepend(DeclSpecAttrs.begin(), DeclSpecAttrs.end()); OriginalDeclSpecAttrs.Range = DeclSpecAttrs.Range; // Parse the common declaration-specifiers piece. ParsingDeclSpec DS(*this); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); ParsedTemplateInfo TemplateInfo; DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context); @@ -2135,7 +2135,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, // list. This ensures that we will not attempt to interpret them as statement // attributes higher up the callchain. ParsedAttributes LocalAttrs(AttrFactory); - LocalAttrs.takeAllFrom(Attrs); + LocalAttrs.takeAllPrependingFrom(Attrs); ParsingDeclarator D(*this, DS, LocalAttrs, Context); if (TemplateInfo.TemplateParams) D.setTemplateParameterLists(*TemplateInfo.TemplateParams); @@ -3462,7 +3462,7 @@ void Parser::ParseDeclarationSpecifiers( PA.setInvalid(); } - DS.takeAttributesFrom(attrs); + DS.takeAttributesAppendingingFrom(attrs); } // If this is not a declaration specifier token, we're done reading decl @@ -3689,7 +3689,7 @@ void Parser::ParseDeclarationSpecifiers( if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) { if (!Attrs.empty()) { AttrsLastTime = true; - attrs.takeAllFrom(Attrs); + attrs.takeAllAppendingFrom(Attrs); } continue; } @@ -3854,7 +3854,7 @@ void Parser::ParseDeclarationSpecifiers( if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) { if (!Attrs.empty()) { AttrsLastTime = true; - attrs.takeAllFrom(Attrs); + attrs.takeAllAppendingFrom(Attrs); } continue; } @@ -4463,7 +4463,7 @@ void Parser::ParseDeclarationSpecifiers( // take them over and handle them here. if (!Attributes.empty()) { AttrsLastTime = true; - attrs.takeAllFrom(Attributes); + attrs.takeAllAppendingFrom(Attributes); } continue; } @@ -4830,7 +4830,7 @@ void Parser::ParseLexedCAttribute(LateParsedAttribute &LA, bool EnterScope, ConsumeAnyToken(); if (OutAttrs) { - OutAttrs->takeAllFrom(Attrs); + OutAttrs->takeAllAppendingFrom(Attrs); } } @@ -6122,7 +6122,7 @@ void Parser::ParseTypeQualifierListOpt( isAllowedCXX11AttributeSpecifier()) { ParsedAttributes Attrs(AttrFactory); ParseCXX11Attributes(Attrs); - DS.takeAttributesFrom(Attrs); + DS.takeAttributesAppendingingFrom(Attrs); } SourceLocation EndLoc; @@ -7483,7 +7483,7 @@ void Parser::ParseParameterDeclarationClause( // Take them so that we only apply the attributes to the first parameter. // We have already started parsing the decl-specifier sequence, so don't // parse any parameter-declaration pieces that precede it. - ArgDeclSpecAttrs.takeAllFrom(FirstArgAttrs); + ArgDeclSpecAttrs.takeAllPrependingFrom(FirstArgAttrs); } else { // Parse any C++11 attributes. MaybeParseCXX11Attributes(ArgDeclAttrs); @@ -7505,7 +7505,7 @@ void Parser::ParseParameterDeclarationClause( DeclSpecContext::DSC_normal, /*LateAttrs=*/nullptr, AllowImplicitTypename); - DS.takeAttributesFrom(ArgDeclSpecAttrs); + DS.takeAttributesAppendingingFrom(ArgDeclSpecAttrs); // Parse the declarator. This is "PrototypeContext" or // "LambdaExprParameterContext", because we must accept either diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index 19f9412..b96968d 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -739,7 +739,7 @@ Parser::DeclGroupPtrTy Parser::ParseUsingDeclaration( << FixItHint::CreateInsertionFromRange( Tok.getLocation(), CharSourceRange::getTokenRange(Range)) << FixItHint::CreateRemoval(Range); - Attrs.takeAllFrom(MisplacedAttrs); + Attrs.takeAllPrependingFrom(MisplacedAttrs); } // Maybe this is an alias-declaration. @@ -787,7 +787,7 @@ Parser::DeclGroupPtrTy Parser::ParseUsingDeclaration( // Parse (optional) attributes. MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs); DiagnoseCXX11AttributeExtension(Attrs); - Attrs.addAll(PrefixAttrs.begin(), PrefixAttrs.end()); + Attrs.prepend(PrefixAttrs.begin(), PrefixAttrs.end()); if (InvalidDeclarator) SkipUntil(tok::comma, tok::semi, StopBeforeMatch); @@ -1948,7 +1948,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, // Recover by adding misplaced attributes to the attribute list // of the class so they can be applied on the class later. - attrs.takeAllFrom(Attributes); + attrs.takeAllAppendingFrom(Attributes); } } @@ -2842,7 +2842,7 @@ Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration( // decl-specifier-seq: // Parse the common declaration-specifiers piece. ParsingDeclSpec DS(*this, TemplateDiags); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); if (MalformedTypeSpec) DS.SetTypeSpecError(); diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp index 90191b0..74f87a8 100644 --- a/clang/lib/Parse/ParseExprCXX.cpp +++ b/clang/lib/Parse/ParseExprCXX.cpp @@ -1244,7 +1244,7 @@ ExprResult Parser::ParseLambdaExpressionAfterIntroducer( break; } - D.takeAttributes(Attributes); + D.takeAttributesAppending(Attributes); } MultiParseScope TemplateParamScope(*this); diff --git a/clang/lib/Parse/ParseObjc.cpp b/clang/lib/Parse/ParseObjc.cpp index a64fb02..0b9f113 100644 --- a/clang/lib/Parse/ParseObjc.cpp +++ b/clang/lib/Parse/ParseObjc.cpp @@ -43,7 +43,7 @@ void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind) { Parser::DeclGroupPtrTy Parser::ParseObjCAtDirectives(ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs) { - DeclAttrs.takeAllFrom(DeclSpecAttrs); + DeclAttrs.takeAllPrependingFrom(DeclSpecAttrs); SourceLocation AtLoc = ConsumeToken(); // the "@" @@ -1065,8 +1065,8 @@ void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, /// Take all the decl attributes out of the given list and add /// them to the given attribute set. -static void takeDeclAttributes(ParsedAttributesView &attrs, - ParsedAttributesView &from) { +static void takeDeclAttributesAppend(ParsedAttributesView &attrs, + ParsedAttributesView &from) { for (auto &AL : llvm::reverse(from)) { if (!AL.isUsedAsTypeAttr()) { from.remove(&AL); @@ -1088,10 +1088,10 @@ static void takeDeclAttributes(ParsedAttributes &attrs, attrs.getPool().takeAllFrom(D.getDeclSpec().getAttributePool()); // Now actually move the attributes over. - takeDeclAttributes(attrs, D.getMutableDeclSpec().getAttributes()); - takeDeclAttributes(attrs, D.getAttributes()); + takeDeclAttributesAppend(attrs, D.getMutableDeclSpec().getAttributes()); + takeDeclAttributesAppend(attrs, D.getAttributes()); for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) - takeDeclAttributes(attrs, D.getTypeObject(i).getAttrs()); + takeDeclAttributesAppend(attrs, D.getTypeObject(i).getAttrs()); } ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, diff --git a/clang/lib/Parse/ParseStmt.cpp b/clang/lib/Parse/ParseStmt.cpp index 2e7af12..9203898 100644 --- a/clang/lib/Parse/ParseStmt.cpp +++ b/clang/lib/Parse/ParseStmt.cpp @@ -718,7 +718,7 @@ StmtResult Parser::ParseLabeledStatement(ParsedAttributes &Attrs, // and followed by a semicolon, GCC will reject (it appears to parse the // attributes as part of a statement in that case). That looks like a bug. if (!getLangOpts().CPlusPlus || Tok.is(tok::semi)) - Attrs.takeAllFrom(TempAttrs); + Attrs.takeAllAppendingFrom(TempAttrs); else { StmtVector Stmts; ParsedAttributes EmptyCXX11Attrs(AttrFactory); @@ -2407,7 +2407,7 @@ StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts, Stmts, StmtCtx, TrailingElseLoc, Attrs, EmptyDeclSpecAttrs, PrecedingLabel); - Attrs.takeAllFrom(TempAttrs); + Attrs.takeAllPrependingFrom(TempAttrs); // Start of attribute range may already be set for some invalid input. // See PR46336. diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp index 74aff0b..dbc7cbc 100644 --- a/clang/lib/Parse/ParseTemplate.cpp +++ b/clang/lib/Parse/ParseTemplate.cpp @@ -196,7 +196,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclarationAfterTemplate( ParsingDeclSpec DS(*this, &DiagsFromTParams); DS.SetRangeStart(DeclSpecAttrs.Range.getBegin()); DS.SetRangeEnd(DeclSpecAttrs.Range.getEnd()); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); ParseDeclarationSpecifiers(DS, TemplateInfo, AS, getDeclSpecContextFromDeclaratorContext(Context)); diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp index a17398b..bbff627 100644 --- a/clang/lib/Parse/Parser.cpp +++ b/clang/lib/Parse/Parser.cpp @@ -1083,7 +1083,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal( "expected uninitialised source range"); DS.SetRangeStart(DeclSpecAttrs.Range.getBegin()); DS.SetRangeEnd(DeclSpecAttrs.Range.getEnd()); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); ParsedTemplateInfo TemplateInfo; MaybeParseMicrosoftAttributes(DS.getAttributes()); @@ -1155,7 +1155,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal( } DS.abort(); - DS.takeAttributesFrom(Attrs); + DS.takeAttributesAppendingingFrom(Attrs); const char *PrevSpec = nullptr; unsigned DiagID; diff --git a/clang/lib/Sema/AnalysisBasedWarnings.cpp b/clang/lib/Sema/AnalysisBasedWarnings.cpp index e9ca8ce..9abaf79 100644 --- a/clang/lib/Sema/AnalysisBasedWarnings.cpp +++ b/clang/lib/Sema/AnalysisBasedWarnings.cpp @@ -29,7 +29,7 @@ #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h" #include "clang/Analysis/Analyses/CalledOnceCheck.h" #include "clang/Analysis/Analyses/Consumed.h" -#include "clang/Analysis/Analyses/LifetimeSafety.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h" #include "clang/Analysis/Analyses/ReachableCode.h" #include "clang/Analysis/Analyses/ThreadSafety.h" #include "clang/Analysis/Analyses/UninitializedValues.h" diff --git a/clang/lib/Sema/CMakeLists.txt b/clang/lib/Sema/CMakeLists.txt index 51e0ee1..0ebf56e 100644 --- a/clang/lib/Sema/CMakeLists.txt +++ b/clang/lib/Sema/CMakeLists.txt @@ -111,6 +111,7 @@ add_clang_library(clangSema clangAPINotes clangAST clangAnalysis + clangAnalysisLifetimeSafety clangBasic clangEdit clangLex diff --git a/clang/lib/Sema/CheckExprLifetime.cpp b/clang/lib/Sema/CheckExprLifetime.cpp index e8a7ad3..8aebf53 100644 --- a/clang/lib/Sema/CheckExprLifetime.cpp +++ b/clang/lib/Sema/CheckExprLifetime.cpp @@ -10,7 +10,7 @@ #include "clang/AST/Decl.h" #include "clang/AST/Expr.h" #include "clang/AST/Type.h" -#include "clang/Analysis/Analyses/LifetimeAnnotations.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h" #include "clang/Basic/DiagnosticSema.h" #include "clang/Sema/Initialization.h" #include "clang/Sema/Sema.h" diff --git a/clang/lib/Sema/DeclSpec.cpp b/clang/lib/Sema/DeclSpec.cpp index 8756ce5..184d31e 100644 --- a/clang/lib/Sema/DeclSpec.cpp +++ b/clang/lib/Sema/DeclSpec.cpp @@ -197,7 +197,7 @@ DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto, [&](DeclSpec::TQ TypeQual, StringRef PrintName, SourceLocation SL) { I.Fun.MethodQualifiers->SetTypeQual(TypeQual, SL); }); - I.Fun.MethodQualifiers->getAttributes().takeAllFrom(attrs); + I.Fun.MethodQualifiers->getAttributes().takeAllPrependingFrom(attrs); I.Fun.MethodQualifiers->getAttributePool().takeAllFrom(attrs.getPool()); } diff --git a/clang/lib/Sema/ParsedAttr.cpp b/clang/lib/Sema/ParsedAttr.cpp index 294f88e..2b5ad33 100644 --- a/clang/lib/Sema/ParsedAttr.cpp +++ b/clang/lib/Sema/ParsedAttr.cpp @@ -304,7 +304,7 @@ bool ParsedAttr::checkAtMostNumArgs(Sema &S, unsigned Num) const { void clang::takeAndConcatenateAttrs(ParsedAttributes &First, ParsedAttributes &&Second) { - First.takeAllAtEndFrom(Second); + First.takeAllAppendingFrom(Second); if (!First.Range.getBegin().isValid()) First.Range.setBegin(Second.Range.getBegin()); diff --git a/clang/lib/Sema/SemaAMDGPU.cpp b/clang/lib/Sema/SemaAMDGPU.cpp index 3a0c231..45fe80d 100644 --- a/clang/lib/Sema/SemaAMDGPU.cpp +++ b/clang/lib/Sema/SemaAMDGPU.cpp @@ -13,6 +13,7 @@ #include "clang/Sema/SemaAMDGPU.h" #include "clang/Basic/DiagnosticSema.h" #include "clang/Basic/TargetBuiltins.h" +#include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Sema/Ownership.h" #include "clang/Sema/Sema.h" #include "llvm/Support/AMDGPUAddrSpace.h" @@ -111,6 +112,108 @@ bool SemaAMDGPU::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, case AMDGPU::BI__builtin_amdgcn_cooperative_atomic_store_16x8B: case AMDGPU::BI__builtin_amdgcn_cooperative_atomic_store_8x16B: return checkCoopAtomicFunctionCall(TheCall, /*IsStore=*/true); + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f16_f32: { + StringRef FeatureList( + getASTContext().BuiltinInfo.getRequiredFeatures(BuiltinID)); + if (!Builtin::evaluateRequiredTargetFeatures(FeatureList, + CallerFeatureMap)) { + Diag(TheCall->getBeginLoc(), diag::err_builtin_needs_feature) + << FD->getDeclName() << FeatureList; + return false; + } + + unsigned ArgCount = TheCall->getNumArgs() - 1; + llvm::APSInt Result; + + return (SemaRef.BuiltinConstantArg(TheCall, 0, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, ArgCount, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, (ArgCount - 1), Result)); + } + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f16_i32: { + StringRef FeatureList( + getASTContext().BuiltinInfo.getRequiredFeatures(BuiltinID)); + if (!Builtin::evaluateRequiredTargetFeatures(FeatureList, + CallerFeatureMap)) { + Diag(TheCall->getBeginLoc(), diag::err_builtin_needs_feature) + << FD->getDeclName() << FeatureList; + return false; + } + + unsigned ArgCount = TheCall->getNumArgs() - 1; + llvm::APSInt Result; + + return (SemaRef.BuiltinConstantArg(TheCall, 1, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, ArgCount, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, (ArgCount - 1), Result)); + } default: return false; } diff --git a/clang/lib/Sema/SemaAPINotes.cpp b/clang/lib/Sema/SemaAPINotes.cpp index 35cdfbf..0d8d0fa 100644 --- a/clang/lib/Sema/SemaAPINotes.cpp +++ b/clang/lib/Sema/SemaAPINotes.cpp @@ -17,7 +17,7 @@ #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/TypeLoc.h" -#include "clang/Analysis/Analyses/LifetimeAnnotations.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h" #include "clang/Basic/SourceLocation.h" #include "clang/Lex/Lexer.h" #include "clang/Sema/SemaObjC.h" diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 6eaf7b9..0e83c20 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -14637,7 +14637,7 @@ StmtResult Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, Declarator D(DS, ParsedAttributesView::none(), DeclaratorContext::ForInit); D.SetIdentifier(Ident, IdentLoc); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/ false), IdentLoc); diff --git a/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp b/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp index 62ae62f2f..abfb176 100644 --- a/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp +++ b/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp @@ -24,7 +24,6 @@ using namespace ento; namespace { struct Registry { - std::vector<BoolEPStat *> BoolStats; std::vector<CounterEPStat *> CounterStats; std::vector<UnsignedMaxEPStat *> UnsignedMaxStats; std::vector<UnsignedEPStat *> UnsignedStats; @@ -33,7 +32,6 @@ struct Registry { struct Snapshot { const Decl *EntryPoint; - std::vector<bool> BoolStatValues; std::vector<unsigned> UnsignedStatValues; void dumpAsCSV(llvm::raw_ostream &OS) const; @@ -48,7 +46,6 @@ static llvm::ManagedStatic<Registry> StatsRegistry; namespace { template <typename Callback> void enumerateStatVectors(const Callback &Fn) { - Fn(StatsRegistry->BoolStats); Fn(StatsRegistry->CounterStats); Fn(StatsRegistry->UnsignedMaxStats); Fn(StatsRegistry->UnsignedStats); @@ -94,12 +91,6 @@ void EntryPointStat::lockRegistry(llvm::StringRef CPPFileName) { return Result; } -BoolEPStat::BoolEPStat(llvm::StringLiteral Name) : EntryPointStat(Name) { - assert(!StatsRegistry->IsLocked); - assert(!isRegistered(Name)); - StatsRegistry->BoolStats.push_back(this); -} - CounterEPStat::CounterEPStat(llvm::StringLiteral Name) : EntryPointStat(Name) { assert(!StatsRegistry->IsLocked); assert(!isRegistered(Name)); @@ -165,28 +156,14 @@ void Registry::Snapshot::dumpAsCSV(llvm::raw_ostream &OS) const { OS << StatsRegistry->EscapedCPPFileName << "\",\""; llvm::printEscapedString( clang::AnalysisDeclContext::getFunctionName(EntryPoint), OS); - OS << "\","; - auto PrintAsBool = [&OS](bool B) { OS << (B ? "true" : "false"); }; - llvm::interleave(BoolStatValues, OS, PrintAsBool, ","); - OS << ((BoolStatValues.empty() || UnsignedStatValues.empty()) ? "" : ","); + OS << "\""; + OS << (UnsignedStatValues.empty() ? "" : ","); llvm::interleave(UnsignedStatValues, OS, [&OS](unsigned U) { OS << U; }, ","); } -static std::vector<bool> consumeBoolStats() { - std::vector<bool> Result; - Result.reserve(StatsRegistry->BoolStats.size()); - for (auto *M : StatsRegistry->BoolStats) { - Result.push_back(M->value()); - M->reset(); - } - return Result; -} - void EntryPointStat::takeSnapshot(const Decl *EntryPoint) { - auto BoolValues = consumeBoolStats(); auto UnsignedValues = consumeUnsignedStats(); - StatsRegistry->Snapshots.push_back( - {EntryPoint, std::move(BoolValues), std::move(UnsignedValues)}); + StatsRegistry->Snapshots.push_back({EntryPoint, std::move(UnsignedValues)}); } void EntryPointStat::dumpStatsAsCSV(llvm::StringRef FileName) { diff --git a/clang/test/C/C2y/n3532.c b/clang/test/C/C2y/n3532.c new file mode 100644 index 0000000..c481b58 --- /dev/null +++ b/clang/test/C/C2y/n3532.c @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -verify -std=c2y %s +// RUN: %clang_cc1 -verify -std=c23 %s +// RUN: %clang_cc1 -verify -std=c17 %s +// RUN: %clang_cc1 -verify -std=c11 %s +// RUN: %clang_cc1 -verify -std=c99 %s +// RUN: %clang_cc1 -verify -std=c89 %s + +/* WG14 N3532: Yes + * Member access of an incomplete object + * + * Verify that the first operand to the . or -> operators is a complete object + * type. + */ + +struct S { + int i; +}; + +union U { + int i; +}; + +void good_test(void) { + struct S s; + struct S *s_ptr = &s; + union U u; + union U *u_ptr = &u; + + // Complete object type, correctly named member. + s.i = 10; + s_ptr->i = 10; + u.i = 10; + u_ptr->i = 10; +} + +void bad_test(void) { + struct Incomplete *s_ptr; /* expected-note 2 {{forward declaration of 'struct Incomplete'}} */ + union AlsoIncomplete *u_ptr; /* expected-note 2 {{forward declaration of 'union AlsoIncomplete'}} */ + struct S s; + union U u; + + // Incomplete object type. + s_ptr->i = 10; /* expected-error {{incomplete definition of type 'struct Incomplete'}} */ + u_ptr->i = 10; /* expected-error {{incomplete definition of type 'union AlsoIncomplete'}} */ + + (*s_ptr).i = 10; /* expected-error {{incomplete definition of type 'struct Incomplete'}} */ + (*u_ptr).i = 10; /* expected-error {{incomplete definition of type 'union AlsoIncomplete'}} */ + + // Complete object type, no named member. + s.f = "test"; /* expected-error {{no member named 'f' in 'struct S'}} */ + u.f = "test"; /* expected-error {{no member named 'f' in 'union U'}} */ +} + diff --git a/clang/test/C/C2y/n3623.c b/clang/test/C/C2y/n3623.c new file mode 100644 index 0000000..a557eda --- /dev/null +++ b/clang/test/C/C2y/n3623.c @@ -0,0 +1,74 @@ +// RUN: %clang_cc1 -verify -std=c2y -DSTD1 %s +// RUN: %clang_cc1 -verify -std=c2y -DSTD2 %s +// RUN: %clang_cc1 -verify=gnu1 -std=gnu2y -DGNU1 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU2 %s +// RUN: %clang_cc1 -verify=gnu3 -std=gnu2y -DGNU3 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU4 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU5 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU6 %s +// RUN: %clang_cc1 -verify=gnu7 -std=gnu2y -DGNU7 %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -verify -std=c2y -DDARWIN1 %s +// RUN: %clang_cc1 -triple x86_64-pc-win32-mscv -verify -std=c2y -fms-compatibility -DMS1 %s +// RUN: %clang_cc1 -triple x86_64-pc-win32-mscv -verify -std=c2y -fms-compatibility -DMS2 %s +// RUN: %clang_cc1 -verify=invalid -std=c2y -DINVALID1 %s +// RUN: %clang_cc1 -verify=invalid -std=c2y -DINVALID2 %s +// expected-no-diagnostics + +/* WG14 N3623: Yes + * Earthly Demon XV: Definition of Main + * + * This validates that we accept the standard type definitions of main or some + * other implementation-defined type. + */ + +typedef __WCHAR_TYPE__ wchar_t; + +// These are the signatures required by the standard. +#if defined(STD1) +int main(void) {} +#elif defined(STD2) +int main(int argc, char *argv[]) {} +#endif + +// GNU extensions. +#if defined(GNU1) +void main(void) {} /* gnu1-warning {{return type of 'main' is not 'int'}} + gnu1-note {{change return type to 'int'}} + */ +#elif defined(GNU2) +const int main(void) {} +#elif defined(GNU3) +int main(...) {} /* gnu3-warning {{'main' is not allowed to be declared variadic}} */ +#elif defined(GNU4) +int main(int, const char **) {} +#elif defined(GNU5) +int main(int, char const * const *) {} +#elif defined(GNU6) +int main(int, char * const *) {} +#elif defined(GNU7) +int main(int) {} /* gnu7-warning {{only one parameter on 'main' declaration}} */ +#endif + +// Darwin extensions. +#if defined(DARWIN1) +int main(int argc, char *argv[], char *environ[], char **undocumented) {} +#endif + +// Microsoft extensions. +#if defined(MS1) +int wmain(int, wchar_t *[]) {} +#elif defined(MS2) +int wmain(int, wchar_t *[], wchar_t *[]) {} +#endif + +// Invalid signatures. +#if defined(INVALID1) +inline int main(int, char *[]); /* invalid-error {{'main' is not allowed to be declared inline}} */ +int main(int, char *[], char *[], float); /* invalid-error {{too many parameters (4) for 'main': must be 0, 2, or 3}} */ +float main(int); /* invalid-error {{'main' must return 'int'}} */ +_Noreturn int main(int, char *[]); /* invalid-warning {{'main' is not allowed to be declared _Noreturn}} + invalid-note {{remove '_Noreturn'}} + */ +#elif defined(INVALID2) +static int main(void); /* invalid-warning {{'main' should not be declared static}} */ +#endif diff --git a/clang/test/CodeGen/backend-unsupported-error.ll b/clang/test/CodeGen/backend-unsupported-error.ll index 2de2c87..47b397b6b 100644 --- a/clang/test/CodeGen/backend-unsupported-error.ll +++ b/clang/test/CodeGen/backend-unsupported-error.ll @@ -21,7 +21,7 @@ entry: ret i32 %call, !dbg !15 } -attributes #0 = { nounwind noinline "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { nounwind noinline "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "use-soft-float"="false" } !llvm.dbg.cu = !{!0} !llvm.module.flags = !{!9, !10} diff --git a/clang/test/CodeGen/builtins-image-load.c b/clang/test/CodeGen/builtins-image-load.c new file mode 100644 index 0000000..8442124 --- /dev/null +++ b/clang/test/CodeGen/builtins-image-load.c @@ -0,0 +1,1203 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1100 %s -emit-llvm -o - | FileCheck %s + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); +typedef _Float16 half; +typedef half half4 __attribute__((ext_vector_type(4))); + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call float @llvm.amdgcn.image.load.2d.f32.i32.v8i32(i32 12, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 106, i32 103) +// CHECK-NEXT: ret float [[TMP3]] +// +float test_builtin_image_load_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(12, i32, i32, tex, 106, 103); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.load.2d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_image_load_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.load.2d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_image_load_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call float @llvm.amdgcn.image.load.2darray.f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP4]] +// +float test_builtin_image_load_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.2darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.2darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = call <4 x float> @llvm.amdgcn.image.load.1d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP2]] +// +float4 test_builtin_image_load_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f32_i32(100, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = call <4 x half> @llvm.amdgcn.image.load.1d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP2]] +// +half4 test_builtin_image_load_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f16_i32(100, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.load.1darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_image_load_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f32_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.load.1darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_image_load_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f16_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.3d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.3d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.cube.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.cube.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.1d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_image_load_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f32_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.1d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_image_load_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f16_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.1darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.1darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_mip_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call float @llvm.amdgcn.image.load.mip.2d.f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP4]] +// +float test_builtin_image_load_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.2d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.2d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_mip_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call float @llvm.amdgcn.image.load.mip.2darray.f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP5]] +// +float test_builtin_image_load_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.2darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_image_load_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.2darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_image_load_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f16_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.3d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_image_load_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.3d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_image_load_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f16_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.cube.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_image_load_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.cube.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_image_load_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f16_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_1d_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.1d.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP2]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_amdgcn_image_sample_1d_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1d_v4f32_f32(100, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_1d_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.1d.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP2]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_amdgcn_image_sample_1d_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1d_v4f16_f32(100, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_1darray_v4f32_f32( +// CHECK-SAME: i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.1darray.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_amdgcn_image_sample_1darray_v4f32_f32(int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1darray_v4f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_1darray_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.1darray.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_amdgcn_image_sample_1darray_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1darray_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_amdgcn_image_sample_2d_f32_f32( +// CHECK-SAME: i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call float @llvm.amdgcn.image.sample.2d.f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP4]] +// +float test_builtin_amdgcn_image_sample_2d_f32_f32(int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2d_f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_2d_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.2d.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_amdgcn_image_sample_2d_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_2d_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.2d.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_amdgcn_image_sample_2d_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_amdgcn_image_sample_2darray_f32_f32( +// CHECK-SAME: i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call float @llvm.amdgcn.image.sample.2darray.f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP5]] +// +float test_builtin_amdgcn_image_sample_2darray_f32_f32(int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2darray_f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_2darray_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.2darray.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_amdgcn_image_sample_2darray_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2darray_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_2darray_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.2darray.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_amdgcn_image_sample_2darray_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2darray_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_3d_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.3d.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_amdgcn_image_sample_3d_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_3d_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_3d_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.3d.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_amdgcn_image_sample_3d_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_3d_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_cube_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.cube.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_amdgcn_image_sample_cube_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_cube_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_cube_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.cube.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_amdgcn_image_sample_cube_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_cube_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} diff --git a/clang/test/CodeGen/builtins-image-store.c b/clang/test/CodeGen/builtins-image-store.c new file mode 100644 index 0000000..5309a16d --- /dev/null +++ b/clang/test/CodeGen/builtins-image-store.c @@ -0,0 +1,730 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1010 %s -emit-llvm -o - | FileCheck %s + +typedef float float4 __attribute__((ext_vector_type(4))); +typedef _Float16 half; +typedef half half4 __attribute__((ext_vector_type(4))); + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2d.f32.i32.v8i32(float [[TMP0]], i32 12, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 106, i32 103) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2d(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2d_f32_i32(f32, 12, i32, i32, tex, 106, 103); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2d_v4f32_i32(v4f32, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2darray.f32.i32.v8i32(float [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2darray_f32_i32(f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1d_v4f32_i32(v4f32, 100, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1d_v4f16_i32(v4f16, 100, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1darray_v4f32_i32(v4f32, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1darray_v4f16_i32(v4f16, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.3d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_3d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.3d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_3d_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.cube.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_cube_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.cube.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_cube_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1d_v4f32_i32(v4f32, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2d.f32.i32.v8i32(float [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2d_f32_i32(f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2d_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2darray.f32.i32.v8i32(float [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2darray_f32_i32(f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.3d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_3d_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.3d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_3d_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.cube.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_cube_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.cube.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_cube_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, 110); + } diff --git a/clang/test/CodeGen/fp-function-attrs.cpp b/clang/test/CodeGen/fp-function-attrs.cpp index e92c26c..3775bd5 100644 --- a/clang/test/CodeGen/fp-function-attrs.cpp +++ b/clang/test/CodeGen/fp-function-attrs.cpp @@ -36,7 +36,7 @@ float test_reassociate_off_pragma(float a, float b, float c) { return tmp; } -// CHECK: define{{.*}} float @_Z27test_reassociate_off_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) [[NO_UNSAFE_ATTRS:#[0-9]+]] +// CHECK: define{{.*}} float @_Z27test_reassociate_off_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) // CHECK: fadd nnan ninf nsz arcp contract afn float {{%.+}}, {{%.+}} // CHECK: fadd fast float {{%.+}}, {{%.+}} @@ -49,10 +49,9 @@ float test_contract_on_pragma(float a, float b, float c) { return tmp; } -// CHECK: define{{.*}} float @_Z23test_contract_on_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) [[NO_UNSAFE_ATTRS:#[0-9]+]] +// CHECK: define{{.*}} float @_Z23test_contract_on_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) // CHECK: fmul fast float {{%.+}}, {{%.+}} // CHECK: fadd reassoc nnan ninf nsz arcp afn float {{%.+}}, {{%.+}} -// CHECK: attributes [[FAST_ATTRS]] = { {{.*}}"no-infs-fp-math"="true" {{.*}}"no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" {{.*}}"unsafe-fp-math"="true"{{.*}} } -// CHECK: attributes [[PRECISE_ATTRS]] = { {{.*}}"no-infs-fp-math"="false" {{.*}}"no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" {{.*}}"unsafe-fp-math"="false"{{.*}} } -// CHECK: attributes [[NO_UNSAFE_ATTRS]] = { {{.*}}"no-infs-fp-math"="true" {{.*}}"no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" {{.*}}"unsafe-fp-math"="false"{{.*}} } +// CHECK: attributes [[FAST_ATTRS]] = { {{.*}}"no-infs-fp-math"="true" {{.*}}"no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true"{{.*}} } +// CHECK: attributes [[PRECISE_ATTRS]] = { {{.*}}"no-infs-fp-math"="false" {{.*}}"no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false"{{.*}} } diff --git a/clang/test/CodeGen/func-attr.c b/clang/test/CodeGen/func-attr.c index 1b36c51..42b7f1c 100644 --- a/clang/test/CodeGen/func-attr.c +++ b/clang/test/CodeGen/func-attr.c @@ -1,18 +1,18 @@ // RUN: %clang_cc1 -triple x86_64-linux-gnu -ffast-math \ // RUN: -ffp-contract=fast -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-UNSAFE,FINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,FINITEONLY // RUN: %clang_cc1 -triple x86_64-linux-gnu -funsafe-math-optimizations \ // RUN: -ffp-contract=fast -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-UNSAFE,NOFINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,NOFINITEONLY // RUN: %clang_cc1 -triple x86_64-linux-gnu -funsafe-math-optimizations \ // RUN: -ffp-contract=on -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-NOUNSAFE,NOFINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,NOFINITEONLY // RUN: %clang_cc1 -triple x86_64-linux-gnu -funsafe-math-optimizations \ // RUN: -ffp-contract=off -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-NOUNSAFE,NOFINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,NOFINITEONLY float foo(float a, float b) { return a+b; @@ -24,6 +24,4 @@ float foo(float a, float b) { // CHECK: attributes [[ATTRS]] = { // CHECK-SAME: "no-signed-zeros-fp-math"="true" // CHECK-SAME: "no-trapping-math"="true" -// CHECK-UNSAFE-SAME: "unsafe-fp-math"="true" -// CHECK-NOUNSAFE-NOT: "unsafe-fp-math"="true" // CHECK-SAME: } diff --git a/clang/test/CodeGenCUDA/propagate-attributes.cu b/clang/test/CodeGenCUDA/propagate-attributes.cu index 6dfd444..a7e6b09 100644 --- a/clang/test/CodeGenCUDA/propagate-attributes.cu +++ b/clang/test/CodeGenCUDA/propagate-attributes.cu @@ -12,18 +12,17 @@ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-builtin-bitcode %t.bc -o - \ // RUN: -fcuda-is-device -triple nvptx-unknown-unknown \ -// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=NOFTZ --check-prefix=NOFAST +// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=NOFTZ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-builtin-bitcode %t.bc \ // RUN: -fdenormal-fp-math-f32=preserve-sign -o - \ // RUN: -fcuda-is-device -triple nvptx-unknown-unknown \ -// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ \ -// RUN: --check-prefix=NOFAST +// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-builtin-bitcode %t.bc \ // RUN: -fdenormal-fp-math-f32=preserve-sign -o - \ // RUN: -fcuda-is-device -funsafe-math-optimizations -triple nvptx-unknown-unknown \ -// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FAST +// RUN: | FileCheck %s --check-prefix=CHECK #ifndef LIB #include "Inputs/cuda.h" @@ -65,9 +64,6 @@ __global__ void kernel() { lib_fn(); } // CHECK-SAME: "no-trapping-math"="true" -// FAST-SAME: "unsafe-fp-math"="true" -// NOFAST-NOT: "unsafe-fp-math"="true" - // Check the attribute list for lib_fn. // CHECK: attributes [[fattr]] = { @@ -81,6 +77,3 @@ __global__ void kernel() { lib_fn(); } // NOFTZ-NOT: "denormal-fp-math-f32" // CHECK-SAME: "no-trapping-math"="true" - -// FAST-SAME: "unsafe-fp-math"="true" -// NOFAST-NOT: "unsafe-fp-math"="true" diff --git a/clang/test/CodeGenOpenCL/relaxed-fpmath.cl b/clang/test/CodeGenOpenCL/relaxed-fpmath.cl index a5f0019..c113d23 100644 --- a/clang/test/CodeGenOpenCL/relaxed-fpmath.cl +++ b/clang/test/CodeGenOpenCL/relaxed-fpmath.cl @@ -33,37 +33,31 @@ float spscalardiv(float a, float b) { // NORMAL-NOT: "no-infs-fp-math" // NORMAL-NOT: "no-nans-fp-math" // NORMAL-NOT: "no-signed-zeros-fp-math" -// NORMAL-NOT: "unsafe-fp-math" // FAST: "less-precise-fpmad"="true" // FAST: "no-infs-fp-math"="true" // FAST: "no-nans-fp-math"="true" // FAST: "no-signed-zeros-fp-math"="true" -// FAST: "unsafe-fp-math"="true" // FINITE-NOT: "less-precise-fpmad" // FINITE: "no-infs-fp-math"="true" // FINITE: "no-nans-fp-math"="true" // FINITE-NOT: "no-signed-zeros-fp-math" -// FINITE-NOT: "unsafe-fp-math" // UNSAFE: "less-precise-fpmad"="true" // UNSAFE-NOT: "no-infs-fp-math" // UNSAFE-NOT: "no-nans-fp-math" // UNSAFE: "no-signed-zeros-fp-math"="true" -// UNSAFE: "unsafe-fp-math"="true" // MAD: "less-precise-fpmad"="true" // MAD-NOT: "no-infs-fp-math" // MAD-NOT: "no-nans-fp-math" // MAD-NOT: "no-signed-zeros-fp-math" -// MAD-NOT: "unsafe-fp-math" // NOSIGNED-NOT: "less-precise-fpmad" // NOSIGNED-NOT: "no-infs-fp-math" // NOSIGNED-NOT: "no-nans-fp-math" // NOSIGNED: "no-signed-zeros-fp-math"="true" -// NOSIGNED-NOT: "unsafe-fp-math" #else // Undefine this to avoid putting it in the PCH. diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_faminmax___sme_AND_sme2_AND_faminmax.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme2_RP_AND_faminmax___sme_AND_sme2_AND_faminmax.c index 1004058..36cb1ba 100644 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_faminmax___sme_AND_sme2_AND_faminmax.c +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme2_RP_AND_faminmax___sme_AND_sme2_AND_faminmax.c @@ -1,14 +1,13 @@ // NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py // RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2 -verify +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -verify // expected-no-diagnostics // REQUIRES: aarch64-registered-target #include <arm_sve.h> -// Properties: guard="sve,sve2,faminmax" streaming_guard="sme,sme2,faminmax" flags="feature-dependent" +// Properties: guard="sve,(sve2|sme2),faminmax" streaming_guard="sme,sme2,faminmax" flags="feature-dependent" void test(void) { float16_t float16_t_val; @@ -19,149 +18,77 @@ void test(void) { svfloat32_t svfloat32_t_val; svfloat64_t svfloat64_t_val; - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svamin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); } @@ -329,220 +256,148 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ svfloat32_t svfloat32_t_val; svfloat64_t svfloat64_t_val; - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_x(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_x(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_x(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_z(svbool_t_val, svfloat16_t_val, float16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_z(svbool_t_val, svfloat32_t_val, float32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_z(svbool_t_val, svfloat64_t_val, float64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svamin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); } diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8___sme_AND_sme2_AND_fp8.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme2_RP_AND_fp8___sme_AND_sme2_AND_fp8.c index a5735d0..2f82298 100644 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8___sme_AND_sme2_AND_fp8.c +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme2_RP_AND_fp8___sme_AND_sme2_AND_fp8.c @@ -1,14 +1,13 @@ // NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py // RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2 -verify +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -verify // expected-no-diagnostics // REQUIRES: aarch64-registered-target #include <arm_sve.h> -// Properties: guard="sve,sve2,fp8" streaming_guard="sme,sme2,fp8" flags="feature-dependent" +// Properties: guard="sve,(sve2|sme2),fp8" streaming_guard="sme,sme2,fp8" flags="feature-dependent" void test(void) { fpm_t fpm_t_val; @@ -17,53 +16,29 @@ void test(void) { svfloat32x2_t svfloat32x2_t_val; svmfloat8_t svmfloat8_t_val; - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt1_f16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt2_f16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt1_f16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt2_f16_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtlt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtn_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtn_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtn_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtn_mf8_fpm(svfloat16x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtnb_mf8_f32_x2_fpm(svfloat32x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtnb_mf8_fpm(svfloat32x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtnt_mf8_f32_x2_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcvtnt_mf8_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); } @@ -131,76 +106,52 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ svfloat32x2_t svfloat32x2_t_val; svmfloat8_t svmfloat8_t_val; - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt1_f16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt2_f16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt1_f16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt2_f16_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtlt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtn_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtn_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtn_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtn_mf8_fpm(svfloat16x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtnb_mf8_f32_x2_fpm(svfloat32x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtnb_mf8_fpm(svfloat32x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtnt_mf8_f32_x2_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcvtnt_mf8_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); } diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_lut___sme_AND_sme2_AND_lut.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme2_RP_AND_lut___sme_AND_sme2_AND_lut.c index f54392c..172fd74 100644 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_lut___sme_AND_sme2_AND_lut.c +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme2_RP_AND_lut___sme_AND_sme2_AND_lut.c @@ -1,14 +1,13 @@ // NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py // RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2 -verify +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sme2 -target-feature +sve -verify // expected-no-diagnostics // REQUIRES: aarch64-registered-target #include <arm_sve.h> -// Properties: guard="sve,sve2,lut" streaming_guard="sme,sme2,lut" flags="feature-dependent" +// Properties: guard="sve,(sve2|sme2),lut" streaming_guard="sme,sme2,lut" flags="feature-dependent" void test(void) { svbfloat16_t svbfloat16_t_val; @@ -22,69 +21,37 @@ void test(void) { svuint16_t svuint16_t_val; svuint16x2_t svuint16x2_t_val; - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane(svbfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane(svfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane(svint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane(svint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane(svuint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane_f16(svfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane_s8(svint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane_s16(svint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti2_lane_u16(svuint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svbfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svbfloat16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svfloat16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svint8_t_val, svuint8_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svint16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svuint8_t_val, svuint8_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svuint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane(svuint16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_bf16_x2(svbfloat16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_f16(svfloat16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_f16_x2(svfloat16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_s8(svint8_t_val, svuint8_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_s16(svint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_s16_x2(svint16x2_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_u8(svuint8_t_val, svuint8_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_u16(svuint16_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svluti4_lane_u16_x2(svuint16x2_t_val, svuint8_t_val, 2); } @@ -178,100 +145,68 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ svuint16_t svuint16_t_val; svuint16x2_t svuint16x2_t_val; - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane(svbfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane(svfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane(svint8_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane(svint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane(svuint8_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane(svuint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane_f16(svfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane_s8(svint8_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane_s16(svint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane_u8(svuint8_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti2_lane_u16(svuint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svbfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svbfloat16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svfloat16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svint8_t_val, svuint8_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svint16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svuint8_t_val, svuint8_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svuint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane(svuint16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_bf16_x2(svbfloat16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_f16(svfloat16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_f16_x2(svfloat16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_s8(svint8_t_val, svuint8_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_s16(svint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_s16_x2(svint16x2_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_u8(svuint8_t_val, svuint8_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_u16(svuint16_t_val, svuint8_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-streaming function}} svluti4_lane_u16_x2(svuint16x2_t_val, svuint8_t_val, 2); } diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme_RP___sme.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme_RP___sme.c new file mode 100644 index 0000000..7e66581 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme_RP___sme.c @@ -0,0 +1,9945 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,(sve2|sme)" streaming_guard="sme" flags="feature-dependent" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + svaba(svint8_t_val, svint8_t_val, int8_t_val); + svaba(svint8_t_val, svint8_t_val, svint8_t_val); + svaba(svint16_t_val, svint16_t_val, int16_t_val); + svaba(svint16_t_val, svint16_t_val, svint16_t_val); + svaba(svint32_t_val, svint32_t_val, int32_t_val); + svaba(svint32_t_val, svint32_t_val, svint32_t_val); + svaba(svint64_t_val, svint64_t_val, int64_t_val); + svaba(svint64_t_val, svint64_t_val, svint64_t_val); + svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svabalb(svint16_t_val, svint8_t_val, int8_t_val); + svabalb(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb(svint32_t_val, svint16_t_val, int16_t_val); + svabalb(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb(svint64_t_val, svint32_t_val, int32_t_val); + svabalb(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svint16_t_val, svint8_t_val, int8_t_val); + svabalt(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt(svint32_t_val, svint16_t_val, int16_t_val); + svabalt(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt(svint64_t_val, svint32_t_val, int32_t_val); + svabalt(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabdlb(svint8_t_val, int8_t_val); + svabdlb(svint8_t_val, svint8_t_val); + svabdlb(svint16_t_val, int16_t_val); + svabdlb(svint16_t_val, svint16_t_val); + svabdlb(svint32_t_val, int32_t_val); + svabdlb(svint32_t_val, svint32_t_val); + svabdlb(svuint8_t_val, svuint8_t_val); + svabdlb(svuint8_t_val, uint8_t_val); + svabdlb(svuint16_t_val, svuint16_t_val); + svabdlb(svuint16_t_val, uint16_t_val); + svabdlb(svuint32_t_val, svuint32_t_val); + svabdlb(svuint32_t_val, uint32_t_val); + svabdlb_n_s16(svint8_t_val, int8_t_val); + svabdlb_n_s32(svint16_t_val, int16_t_val); + svabdlb_n_s64(svint32_t_val, int32_t_val); + svabdlb_n_u16(svuint8_t_val, uint8_t_val); + svabdlb_n_u32(svuint16_t_val, uint16_t_val); + svabdlb_n_u64(svuint32_t_val, uint32_t_val); + svabdlb_s16(svint8_t_val, svint8_t_val); + svabdlb_s32(svint16_t_val, svint16_t_val); + svabdlb_s64(svint32_t_val, svint32_t_val); + svabdlb_u16(svuint8_t_val, svuint8_t_val); + svabdlb_u32(svuint16_t_val, svuint16_t_val); + svabdlb_u64(svuint32_t_val, svuint32_t_val); + svabdlt(svint8_t_val, int8_t_val); + svabdlt(svint8_t_val, svint8_t_val); + svabdlt(svint16_t_val, int16_t_val); + svabdlt(svint16_t_val, svint16_t_val); + svabdlt(svint32_t_val, int32_t_val); + svabdlt(svint32_t_val, svint32_t_val); + svabdlt(svuint8_t_val, svuint8_t_val); + svabdlt(svuint8_t_val, uint8_t_val); + svabdlt(svuint16_t_val, svuint16_t_val); + svabdlt(svuint16_t_val, uint16_t_val); + svabdlt(svuint32_t_val, svuint32_t_val); + svabdlt(svuint32_t_val, uint32_t_val); + svabdlt_n_s16(svint8_t_val, int8_t_val); + svabdlt_n_s32(svint16_t_val, int16_t_val); + svabdlt_n_s64(svint32_t_val, int32_t_val); + svabdlt_n_u16(svuint8_t_val, uint8_t_val); + svabdlt_n_u32(svuint16_t_val, uint16_t_val); + svabdlt_n_u64(svuint32_t_val, uint32_t_val); + svabdlt_s16(svint8_t_val, svint8_t_val); + svabdlt_s32(svint16_t_val, svint16_t_val); + svabdlt_s64(svint32_t_val, svint32_t_val); + svabdlt_u16(svuint8_t_val, svuint8_t_val); + svabdlt_u32(svuint16_t_val, svuint16_t_val); + svabdlt_u64(svuint32_t_val, svuint32_t_val); + svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaddhnb(svint16_t_val, int16_t_val); + svaddhnb(svint16_t_val, svint16_t_val); + svaddhnb(svint32_t_val, int32_t_val); + svaddhnb(svint32_t_val, svint32_t_val); + svaddhnb(svint64_t_val, int64_t_val); + svaddhnb(svint64_t_val, svint64_t_val); + svaddhnb(svuint16_t_val, svuint16_t_val); + svaddhnb(svuint16_t_val, uint16_t_val); + svaddhnb(svuint32_t_val, svuint32_t_val); + svaddhnb(svuint32_t_val, uint32_t_val); + svaddhnb(svuint64_t_val, svuint64_t_val); + svaddhnb(svuint64_t_val, uint64_t_val); + svaddhnb_n_s16(svint16_t_val, int16_t_val); + svaddhnb_n_s32(svint32_t_val, int32_t_val); + svaddhnb_n_s64(svint64_t_val, int64_t_val); + svaddhnb_n_u16(svuint16_t_val, uint16_t_val); + svaddhnb_n_u32(svuint32_t_val, uint32_t_val); + svaddhnb_n_u64(svuint64_t_val, uint64_t_val); + svaddhnb_s16(svint16_t_val, svint16_t_val); + svaddhnb_s32(svint32_t_val, svint32_t_val); + svaddhnb_s64(svint64_t_val, svint64_t_val); + svaddhnb_u16(svuint16_t_val, svuint16_t_val); + svaddhnb_u32(svuint32_t_val, svuint32_t_val); + svaddhnb_u64(svuint64_t_val, svuint64_t_val); + svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddlb(svint8_t_val, int8_t_val); + svaddlb(svint8_t_val, svint8_t_val); + svaddlb(svint16_t_val, int16_t_val); + svaddlb(svint16_t_val, svint16_t_val); + svaddlb(svint32_t_val, int32_t_val); + svaddlb(svint32_t_val, svint32_t_val); + svaddlb(svuint8_t_val, svuint8_t_val); + svaddlb(svuint8_t_val, uint8_t_val); + svaddlb(svuint16_t_val, svuint16_t_val); + svaddlb(svuint16_t_val, uint16_t_val); + svaddlb(svuint32_t_val, svuint32_t_val); + svaddlb(svuint32_t_val, uint32_t_val); + svaddlb_n_s16(svint8_t_val, int8_t_val); + svaddlb_n_s32(svint16_t_val, int16_t_val); + svaddlb_n_s64(svint32_t_val, int32_t_val); + svaddlb_n_u16(svuint8_t_val, uint8_t_val); + svaddlb_n_u32(svuint16_t_val, uint16_t_val); + svaddlb_n_u64(svuint32_t_val, uint32_t_val); + svaddlb_s16(svint8_t_val, svint8_t_val); + svaddlb_s32(svint16_t_val, svint16_t_val); + svaddlb_s64(svint32_t_val, svint32_t_val); + svaddlb_u16(svuint8_t_val, svuint8_t_val); + svaddlb_u32(svuint16_t_val, svuint16_t_val); + svaddlb_u64(svuint32_t_val, svuint32_t_val); + svaddlbt(svint8_t_val, int8_t_val); + svaddlbt(svint8_t_val, svint8_t_val); + svaddlbt(svint16_t_val, int16_t_val); + svaddlbt(svint16_t_val, svint16_t_val); + svaddlbt(svint32_t_val, int32_t_val); + svaddlbt(svint32_t_val, svint32_t_val); + svaddlbt_n_s16(svint8_t_val, int8_t_val); + svaddlbt_n_s32(svint16_t_val, int16_t_val); + svaddlbt_n_s64(svint32_t_val, int32_t_val); + svaddlbt_s16(svint8_t_val, svint8_t_val); + svaddlbt_s32(svint16_t_val, svint16_t_val); + svaddlbt_s64(svint32_t_val, svint32_t_val); + svaddlt(svint8_t_val, int8_t_val); + svaddlt(svint8_t_val, svint8_t_val); + svaddlt(svint16_t_val, int16_t_val); + svaddlt(svint16_t_val, svint16_t_val); + svaddlt(svint32_t_val, int32_t_val); + svaddlt(svint32_t_val, svint32_t_val); + svaddlt(svuint8_t_val, svuint8_t_val); + svaddlt(svuint8_t_val, uint8_t_val); + svaddlt(svuint16_t_val, svuint16_t_val); + svaddlt(svuint16_t_val, uint16_t_val); + svaddlt(svuint32_t_val, svuint32_t_val); + svaddlt(svuint32_t_val, uint32_t_val); + svaddlt_n_s16(svint8_t_val, int8_t_val); + svaddlt_n_s32(svint16_t_val, int16_t_val); + svaddlt_n_s64(svint32_t_val, int32_t_val); + svaddlt_n_u16(svuint8_t_val, uint8_t_val); + svaddlt_n_u32(svuint16_t_val, uint16_t_val); + svaddlt_n_u64(svuint32_t_val, uint32_t_val); + svaddlt_s16(svint8_t_val, svint8_t_val); + svaddlt_s32(svint16_t_val, svint16_t_val); + svaddlt_s64(svint32_t_val, svint32_t_val); + svaddlt_u16(svuint8_t_val, svuint8_t_val); + svaddlt_u32(svuint16_t_val, svuint16_t_val); + svaddlt_u64(svuint32_t_val, svuint32_t_val); + svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddwb(svint16_t_val, int8_t_val); + svaddwb(svint16_t_val, svint8_t_val); + svaddwb(svint32_t_val, int16_t_val); + svaddwb(svint32_t_val, svint16_t_val); + svaddwb(svint64_t_val, int32_t_val); + svaddwb(svint64_t_val, svint32_t_val); + svaddwb(svuint16_t_val, svuint8_t_val); + svaddwb(svuint16_t_val, uint8_t_val); + svaddwb(svuint32_t_val, svuint16_t_val); + svaddwb(svuint32_t_val, uint16_t_val); + svaddwb(svuint64_t_val, svuint32_t_val); + svaddwb(svuint64_t_val, uint32_t_val); + svaddwb_n_s16(svint16_t_val, int8_t_val); + svaddwb_n_s32(svint32_t_val, int16_t_val); + svaddwb_n_s64(svint64_t_val, int32_t_val); + svaddwb_n_u16(svuint16_t_val, uint8_t_val); + svaddwb_n_u32(svuint32_t_val, uint16_t_val); + svaddwb_n_u64(svuint64_t_val, uint32_t_val); + svaddwb_s16(svint16_t_val, svint8_t_val); + svaddwb_s32(svint32_t_val, svint16_t_val); + svaddwb_s64(svint64_t_val, svint32_t_val); + svaddwb_u16(svuint16_t_val, svuint8_t_val); + svaddwb_u32(svuint32_t_val, svuint16_t_val); + svaddwb_u64(svuint64_t_val, svuint32_t_val); + svaddwt(svint16_t_val, int8_t_val); + svaddwt(svint16_t_val, svint8_t_val); + svaddwt(svint32_t_val, int16_t_val); + svaddwt(svint32_t_val, svint16_t_val); + svaddwt(svint64_t_val, int32_t_val); + svaddwt(svint64_t_val, svint32_t_val); + svaddwt(svuint16_t_val, svuint8_t_val); + svaddwt(svuint16_t_val, uint8_t_val); + svaddwt(svuint32_t_val, svuint16_t_val); + svaddwt(svuint32_t_val, uint16_t_val); + svaddwt(svuint64_t_val, svuint32_t_val); + svaddwt(svuint64_t_val, uint32_t_val); + svaddwt_n_s16(svint16_t_val, int8_t_val); + svaddwt_n_s32(svint32_t_val, int16_t_val); + svaddwt_n_s64(svint64_t_val, int32_t_val); + svaddwt_n_u16(svuint16_t_val, uint8_t_val); + svaddwt_n_u32(svuint32_t_val, uint16_t_val); + svaddwt_n_u64(svuint64_t_val, uint32_t_val); + svaddwt_s16(svint16_t_val, svint8_t_val); + svaddwt_s32(svint32_t_val, svint16_t_val); + svaddwt_s64(svint64_t_val, svint32_t_val); + svaddwt_u16(svuint16_t_val, svuint8_t_val); + svaddwt_u32(svuint32_t_val, svuint16_t_val); + svaddwt_u64(svuint64_t_val, svuint32_t_val); + svbcax(svint8_t_val, svint8_t_val, int8_t_val); + svbcax(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax(svint16_t_val, svint16_t_val, int16_t_val); + svbcax(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax(svint32_t_val, svint32_t_val, int32_t_val); + svbcax(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax(svint64_t_val, svint64_t_val, int64_t_val); + svbcax(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svint8_t_val, svint8_t_val, int8_t_val); + svbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl(svint16_t_val, svint16_t_val, int16_t_val); + svbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl(svint32_t_val, svint32_t_val, int32_t_val); + svbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl(svint64_t_val, svint64_t_val, int64_t_val); + svbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcadd(svint8_t_val, svint8_t_val, 90); + svcadd(svint16_t_val, svint16_t_val, 90); + svcadd(svint32_t_val, svint32_t_val, 90); + svcadd(svint64_t_val, svint64_t_val, 90); + svcadd(svuint8_t_val, svuint8_t_val, 90); + svcadd(svuint16_t_val, svuint16_t_val, 90); + svcadd(svuint32_t_val, svuint32_t_val, 90); + svcadd(svuint64_t_val, svuint64_t_val, 90); + svcadd_s8(svint8_t_val, svint8_t_val, 90); + svcadd_s16(svint16_t_val, svint16_t_val, 90); + svcadd_s32(svint32_t_val, svint32_t_val, 90); + svcadd_s64(svint64_t_val, svint64_t_val, 90); + svcadd_u8(svuint8_t_val, svuint8_t_val, 90); + svcadd_u16(svuint16_t_val, svuint16_t_val, 90); + svcadd_u32(svuint32_t_val, svuint32_t_val, 90); + svcadd_u64(svuint64_t_val, svuint64_t_val, 90); + svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); + svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_z(svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + sveor3(svint8_t_val, svint8_t_val, int8_t_val); + sveor3(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3(svint16_t_val, svint16_t_val, int16_t_val); + sveor3(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3(svint32_t_val, svint32_t_val, int32_t_val); + sveor3(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3(svint64_t_val, svint64_t_val, int64_t_val); + sveor3(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svint8_t_val, svint8_t_val, int8_t_val); + sveortb(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb(svint16_t_val, svint16_t_val, int16_t_val); + sveortb(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb(svint32_t_val, svint32_t_val, int32_t_val); + sveortb(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb(svint64_t_val, svint64_t_val, int64_t_val); + sveortb(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_f16_x(svbool_t_val, svfloat16_t_val); + svlogb_f16_z(svbool_t_val, svfloat16_t_val); + svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_f32_x(svbool_t_val, svfloat32_t_val); + svlogb_f32_z(svbool_t_val, svfloat32_t_val); + svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_f64_x(svbool_t_val, svfloat64_t_val); + svlogb_f64_z(svbool_t_val, svfloat64_t_val); + svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_x(svbool_t_val, svfloat16_t_val); + svlogb_x(svbool_t_val, svfloat32_t_val); + svlogb_x(svbool_t_val, svfloat64_t_val); + svlogb_z(svbool_t_val, svfloat16_t_val); + svlogb_z(svbool_t_val, svfloat32_t_val); + svlogb_z(svbool_t_val, svfloat64_t_val); + svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmovlb(svint8_t_val); + svmovlb(svint16_t_val); + svmovlb(svint32_t_val); + svmovlb(svuint8_t_val); + svmovlb(svuint16_t_val); + svmovlb(svuint32_t_val); + svmovlb_s16(svint8_t_val); + svmovlb_s32(svint16_t_val); + svmovlb_s64(svint32_t_val); + svmovlb_u16(svuint8_t_val); + svmovlb_u32(svuint16_t_val); + svmovlb_u64(svuint32_t_val); + svmovlt(svint8_t_val); + svmovlt(svint16_t_val); + svmovlt(svint32_t_val); + svmovlt(svuint8_t_val); + svmovlt(svuint16_t_val); + svmovlt(svuint32_t_val); + svmovlt_s16(svint8_t_val); + svmovlt_s32(svint16_t_val); + svmovlt_s64(svint32_t_val); + svmovlt_u16(svuint8_t_val); + svmovlt_u32(svuint16_t_val); + svmovlt_u64(svuint32_t_val); + svmul_lane(svint16_t_val, svint16_t_val, 1); + svmul_lane(svint32_t_val, svint32_t_val, 1); + svmul_lane(svint64_t_val, svint64_t_val, 1); + svmul_lane(svuint16_t_val, svuint16_t_val, 1); + svmul_lane(svuint32_t_val, svuint32_t_val, 1); + svmul_lane(svuint64_t_val, svuint64_t_val, 1); + svmul_lane_s16(svint16_t_val, svint16_t_val, 1); + svmul_lane_s32(svint32_t_val, svint32_t_val, 1); + svmul_lane_s64(svint64_t_val, svint64_t_val, 1); + svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); + svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); + svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); + svmullb(svint8_t_val, int8_t_val); + svmullb(svint8_t_val, svint8_t_val); + svmullb(svint16_t_val, int16_t_val); + svmullb(svint16_t_val, svint16_t_val); + svmullb(svint32_t_val, int32_t_val); + svmullb(svint32_t_val, svint32_t_val); + svmullb(svuint8_t_val, svuint8_t_val); + svmullb(svuint8_t_val, uint8_t_val); + svmullb(svuint16_t_val, svuint16_t_val); + svmullb(svuint16_t_val, uint16_t_val); + svmullb(svuint32_t_val, svuint32_t_val); + svmullb(svuint32_t_val, uint32_t_val); + svmullb_lane(svint16_t_val, svint16_t_val, 1); + svmullb_lane(svint32_t_val, svint32_t_val, 1); + svmullb_lane(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane(svuint32_t_val, svuint32_t_val, 1); + svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullb_n_s16(svint8_t_val, int8_t_val); + svmullb_n_s32(svint16_t_val, int16_t_val); + svmullb_n_s64(svint32_t_val, int32_t_val); + svmullb_n_u16(svuint8_t_val, uint8_t_val); + svmullb_n_u32(svuint16_t_val, uint16_t_val); + svmullb_n_u64(svuint32_t_val, uint32_t_val); + svmullb_s16(svint8_t_val, svint8_t_val); + svmullb_s32(svint16_t_val, svint16_t_val); + svmullb_s64(svint32_t_val, svint32_t_val); + svmullb_u16(svuint8_t_val, svuint8_t_val); + svmullb_u32(svuint16_t_val, svuint16_t_val); + svmullb_u64(svuint32_t_val, svuint32_t_val); + svmullt(svint8_t_val, int8_t_val); + svmullt(svint8_t_val, svint8_t_val); + svmullt(svint16_t_val, int16_t_val); + svmullt(svint16_t_val, svint16_t_val); + svmullt(svint32_t_val, int32_t_val); + svmullt(svint32_t_val, svint32_t_val); + svmullt(svuint8_t_val, svuint8_t_val); + svmullt(svuint8_t_val, uint8_t_val); + svmullt(svuint16_t_val, svuint16_t_val); + svmullt(svuint16_t_val, uint16_t_val); + svmullt(svuint32_t_val, svuint32_t_val); + svmullt(svuint32_t_val, uint32_t_val); + svmullt_lane(svint16_t_val, svint16_t_val, 1); + svmullt_lane(svint32_t_val, svint32_t_val, 1); + svmullt_lane(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane(svuint32_t_val, svuint32_t_val, 1); + svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullt_n_s16(svint8_t_val, int8_t_val); + svmullt_n_s32(svint16_t_val, int16_t_val); + svmullt_n_s64(svint32_t_val, int32_t_val); + svmullt_n_u16(svuint8_t_val, uint8_t_val); + svmullt_n_u32(svuint16_t_val, uint16_t_val); + svmullt_n_u64(svuint32_t_val, uint32_t_val); + svmullt_s16(svint8_t_val, svint8_t_val); + svmullt_s32(svint16_t_val, svint16_t_val); + svmullt_s64(svint32_t_val, svint32_t_val); + svmullt_u16(svuint8_t_val, svuint8_t_val); + svmullt_u32(svuint16_t_val, svuint16_t_val); + svmullt_u64(svuint32_t_val, svuint32_t_val); + svnbsl(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpmul(svuint8_t_val, svuint8_t_val); + svpmul(svuint8_t_val, uint8_t_val); + svpmul_n_u8(svuint8_t_val, uint8_t_val); + svpmul_u8(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, uint8_t_val); + svpmullb(svuint32_t_val, svuint32_t_val); + svpmullb(svuint32_t_val, uint32_t_val); + svpmullb_n_u16(svuint8_t_val, uint8_t_val); + svpmullb_n_u64(svuint32_t_val, uint32_t_val); + svpmullb_pair(svuint8_t_val, svuint8_t_val); + svpmullb_pair(svuint8_t_val, uint8_t_val); + svpmullb_pair(svuint32_t_val, svuint32_t_val); + svpmullb_pair(svuint32_t_val, uint32_t_val); + svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullb_u16(svuint8_t_val, svuint8_t_val); + svpmullb_u64(svuint32_t_val, svuint32_t_val); + svpmullt(svuint8_t_val, svuint8_t_val); + svpmullt(svuint8_t_val, uint8_t_val); + svpmullt(svuint32_t_val, svuint32_t_val); + svpmullt(svuint32_t_val, uint32_t_val); + svpmullt_n_u16(svuint8_t_val, uint8_t_val); + svpmullt_n_u64(svuint32_t_val, uint32_t_val); + svpmullt_pair(svuint8_t_val, svuint8_t_val); + svpmullt_pair(svuint8_t_val, uint8_t_val); + svpmullt_pair(svuint32_t_val, svuint32_t_val); + svpmullt_pair(svuint32_t_val, uint32_t_val); + svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullt_u16(svuint8_t_val, svuint8_t_val); + svpmullt_u64(svuint32_t_val, svuint32_t_val); + svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_s8_x(svbool_t_val, svint8_t_val); + svqabs_s8_z(svbool_t_val, svint8_t_val); + svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_s16_x(svbool_t_val, svint16_t_val); + svqabs_s16_z(svbool_t_val, svint16_t_val); + svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_s32_x(svbool_t_val, svint32_t_val); + svqabs_s32_z(svbool_t_val, svint32_t_val); + svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s64_x(svbool_t_val, svint64_t_val); + svqabs_s64_z(svbool_t_val, svint64_t_val); + svqabs_x(svbool_t_val, svint8_t_val); + svqabs_x(svbool_t_val, svint16_t_val); + svqabs_x(svbool_t_val, svint32_t_val); + svqabs_x(svbool_t_val, svint64_t_val); + svqabs_z(svbool_t_val, svint8_t_val); + svqabs_z(svbool_t_val, svint16_t_val); + svqabs_z(svbool_t_val, svint32_t_val); + svqabs_z(svbool_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqcadd(svint8_t_val, svint8_t_val, 90); + svqcadd(svint16_t_val, svint16_t_val, 90); + svqcadd(svint32_t_val, svint32_t_val, 90); + svqcadd(svint64_t_val, svint64_t_val, 90); + svqcadd_s8(svint8_t_val, svint8_t_val, 90); + svqcadd_s16(svint16_t_val, svint16_t_val, 90); + svqcadd_s32(svint32_t_val, svint32_t_val, 90); + svqcadd_s64(svint64_t_val, svint64_t_val, 90); + svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmulh(svint8_t_val, int8_t_val); + svqdmulh(svint8_t_val, svint8_t_val); + svqdmulh(svint16_t_val, int16_t_val); + svqdmulh(svint16_t_val, svint16_t_val); + svqdmulh(svint32_t_val, int32_t_val); + svqdmulh(svint32_t_val, svint32_t_val); + svqdmulh(svint64_t_val, int64_t_val); + svqdmulh(svint64_t_val, svint64_t_val); + svqdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqdmulh_n_s8(svint8_t_val, int8_t_val); + svqdmulh_n_s16(svint16_t_val, int16_t_val); + svqdmulh_n_s32(svint32_t_val, int32_t_val); + svqdmulh_n_s64(svint64_t_val, int64_t_val); + svqdmulh_s8(svint8_t_val, svint8_t_val); + svqdmulh_s16(svint16_t_val, svint16_t_val); + svqdmulh_s32(svint32_t_val, svint32_t_val); + svqdmulh_s64(svint64_t_val, svint64_t_val); + svqdmullb(svint8_t_val, int8_t_val); + svqdmullb(svint8_t_val, svint8_t_val); + svqdmullb(svint16_t_val, int16_t_val); + svqdmullb(svint16_t_val, svint16_t_val); + svqdmullb(svint32_t_val, int32_t_val); + svqdmullb(svint32_t_val, svint32_t_val); + svqdmullb_lane(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane(svint32_t_val, svint32_t_val, 1); + svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullb_n_s16(svint8_t_val, int8_t_val); + svqdmullb_n_s32(svint16_t_val, int16_t_val); + svqdmullb_n_s64(svint32_t_val, int32_t_val); + svqdmullb_s16(svint8_t_val, svint8_t_val); + svqdmullb_s32(svint16_t_val, svint16_t_val); + svqdmullb_s64(svint32_t_val, svint32_t_val); + svqdmullt(svint8_t_val, int8_t_val); + svqdmullt(svint8_t_val, svint8_t_val); + svqdmullt(svint16_t_val, int16_t_val); + svqdmullt(svint16_t_val, svint16_t_val); + svqdmullt(svint32_t_val, int32_t_val); + svqdmullt(svint32_t_val, svint32_t_val); + svqdmullt_lane(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane(svint32_t_val, svint32_t_val, 1); + svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullt_n_s16(svint8_t_val, int8_t_val); + svqdmullt_n_s32(svint16_t_val, int16_t_val); + svqdmullt_n_s64(svint32_t_val, int32_t_val); + svqdmullt_s16(svint8_t_val, svint8_t_val); + svqdmullt_s32(svint16_t_val, svint16_t_val); + svqdmullt_s64(svint32_t_val, svint32_t_val); + svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_s8_x(svbool_t_val, svint8_t_val); + svqneg_s8_z(svbool_t_val, svint8_t_val); + svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_s16_x(svbool_t_val, svint16_t_val); + svqneg_s16_z(svbool_t_val, svint16_t_val); + svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_s32_x(svbool_t_val, svint32_t_val); + svqneg_s32_z(svbool_t_val, svint32_t_val); + svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s64_x(svbool_t_val, svint64_t_val); + svqneg_s64_z(svbool_t_val, svint64_t_val); + svqneg_x(svbool_t_val, svint8_t_val); + svqneg_x(svbool_t_val, svint16_t_val); + svqneg_x(svbool_t_val, svint32_t_val); + svqneg_x(svbool_t_val, svint64_t_val); + svqneg_z(svbool_t_val, svint8_t_val); + svqneg_z(svbool_t_val, svint16_t_val); + svqneg_z(svbool_t_val, svint32_t_val); + svqneg_z(svbool_t_val, svint64_t_val); + svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmulh(svint8_t_val, int8_t_val); + svqrdmulh(svint8_t_val, svint8_t_val); + svqrdmulh(svint16_t_val, int16_t_val); + svqrdmulh(svint16_t_val, svint16_t_val); + svqrdmulh(svint32_t_val, int32_t_val); + svqrdmulh(svint32_t_val, svint32_t_val); + svqrdmulh(svint64_t_val, int64_t_val); + svqrdmulh(svint64_t_val, svint64_t_val); + svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqrdmulh_n_s8(svint8_t_val, int8_t_val); + svqrdmulh_n_s16(svint16_t_val, int16_t_val); + svqrdmulh_n_s32(svint32_t_val, int32_t_val); + svqrdmulh_n_s64(svint64_t_val, int64_t_val); + svqrdmulh_s8(svint8_t_val, svint8_t_val); + svqrdmulh_s16(svint16_t_val, svint16_t_val); + svqrdmulh_s32(svint32_t_val, svint32_t_val); + svqrdmulh_s64(svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshrnb(svint16_t_val, 2); + svqrshrnb(svint32_t_val, 2); + svqrshrnb(svint64_t_val, 2); + svqrshrnb(svuint16_t_val, 2); + svqrshrnb(svuint32_t_val, 2); + svqrshrnb(svuint64_t_val, 2); + svqrshrnb_n_s16(svint16_t_val, 2); + svqrshrnb_n_s32(svint32_t_val, 2); + svqrshrnb_n_s64(svint64_t_val, 2); + svqrshrnb_n_u16(svuint16_t_val, 2); + svqrshrnb_n_u32(svuint32_t_val, 2); + svqrshrnb_n_u64(svuint64_t_val, 2); + svqrshrnt(svint8_t_val, svint16_t_val, 2); + svqrshrnt(svint16_t_val, svint32_t_val, 2); + svqrshrnt(svint32_t_val, svint64_t_val, 2); + svqrshrnt(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt(svuint32_t_val, svuint64_t_val, 2); + svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqrshrunb(svint16_t_val, 2); + svqrshrunb(svint32_t_val, 2); + svqrshrunb(svint64_t_val, 2); + svqrshrunb_n_s16(svint16_t_val, 2); + svqrshrunb_n_s32(svint32_t_val, 2); + svqrshrunb_n_s64(svint64_t_val, 2); + svqrshrunt(svuint8_t_val, svint16_t_val, 2); + svqrshrunt(svuint16_t_val, svint32_t_val, 2); + svqrshrunt(svuint32_t_val, svint64_t_val, 2); + svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshlu_m(svbool_t_val, svint8_t_val, 2); + svqshlu_m(svbool_t_val, svint16_t_val, 2); + svqshlu_m(svbool_t_val, svint32_t_val, 2); + svqshlu_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); + svqshlu_x(svbool_t_val, svint8_t_val, 2); + svqshlu_x(svbool_t_val, svint16_t_val, 2); + svqshlu_x(svbool_t_val, svint32_t_val, 2); + svqshlu_x(svbool_t_val, svint64_t_val, 2); + svqshlu_z(svbool_t_val, svint8_t_val, 2); + svqshlu_z(svbool_t_val, svint16_t_val, 2); + svqshlu_z(svbool_t_val, svint32_t_val, 2); + svqshlu_z(svbool_t_val, svint64_t_val, 2); + svqshrnb(svint16_t_val, 2); + svqshrnb(svint32_t_val, 2); + svqshrnb(svint64_t_val, 2); + svqshrnb(svuint16_t_val, 2); + svqshrnb(svuint32_t_val, 2); + svqshrnb(svuint64_t_val, 2); + svqshrnb_n_s16(svint16_t_val, 2); + svqshrnb_n_s32(svint32_t_val, 2); + svqshrnb_n_s64(svint64_t_val, 2); + svqshrnb_n_u16(svuint16_t_val, 2); + svqshrnb_n_u32(svuint32_t_val, 2); + svqshrnb_n_u64(svuint64_t_val, 2); + svqshrnt(svint8_t_val, svint16_t_val, 2); + svqshrnt(svint16_t_val, svint32_t_val, 2); + svqshrnt(svint32_t_val, svint64_t_val, 2); + svqshrnt(svuint8_t_val, svuint16_t_val, 2); + svqshrnt(svuint16_t_val, svuint32_t_val, 2); + svqshrnt(svuint32_t_val, svuint64_t_val, 2); + svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqshrunb(svint16_t_val, 2); + svqshrunb(svint32_t_val, 2); + svqshrunb(svint64_t_val, 2); + svqshrunb_n_s16(svint16_t_val, 2); + svqshrunb_n_s32(svint32_t_val, 2); + svqshrunb_n_s64(svint64_t_val, 2); + svqshrunt(svuint8_t_val, svint16_t_val, 2); + svqshrunt(svuint16_t_val, svint32_t_val, 2); + svqshrunt(svuint32_t_val, svint64_t_val, 2); + svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqxtnb(svint16_t_val); + svqxtnb(svint32_t_val); + svqxtnb(svint64_t_val); + svqxtnb(svuint16_t_val); + svqxtnb(svuint32_t_val); + svqxtnb(svuint64_t_val); + svqxtnb_s16(svint16_t_val); + svqxtnb_s32(svint32_t_val); + svqxtnb_s64(svint64_t_val); + svqxtnb_u16(svuint16_t_val); + svqxtnb_u32(svuint32_t_val); + svqxtnb_u64(svuint64_t_val); + svqxtnt(svint8_t_val, svint16_t_val); + svqxtnt(svint16_t_val, svint32_t_val); + svqxtnt(svint32_t_val, svint64_t_val); + svqxtnt(svuint8_t_val, svuint16_t_val); + svqxtnt(svuint16_t_val, svuint32_t_val); + svqxtnt(svuint32_t_val, svuint64_t_val); + svqxtnt_s16(svint8_t_val, svint16_t_val); + svqxtnt_s32(svint16_t_val, svint32_t_val); + svqxtnt_s64(svint32_t_val, svint64_t_val); + svqxtnt_u16(svuint8_t_val, svuint16_t_val); + svqxtnt_u32(svuint16_t_val, svuint32_t_val); + svqxtnt_u64(svuint32_t_val, svuint64_t_val); + svqxtunb(svint16_t_val); + svqxtunb(svint32_t_val); + svqxtunb(svint64_t_val); + svqxtunb_s16(svint16_t_val); + svqxtunb_s32(svint32_t_val); + svqxtunb_s64(svint64_t_val); + svqxtunt(svuint8_t_val, svint16_t_val); + svqxtunt(svuint16_t_val, svint32_t_val); + svqxtunt(svuint32_t_val, svint64_t_val); + svqxtunt_s16(svuint8_t_val, svint16_t_val); + svqxtunt_s32(svuint16_t_val, svint32_t_val); + svqxtunt_s64(svuint32_t_val, svint64_t_val); + svraddhnb(svint16_t_val, int16_t_val); + svraddhnb(svint16_t_val, svint16_t_val); + svraddhnb(svint32_t_val, int32_t_val); + svraddhnb(svint32_t_val, svint32_t_val); + svraddhnb(svint64_t_val, int64_t_val); + svraddhnb(svint64_t_val, svint64_t_val); + svraddhnb(svuint16_t_val, svuint16_t_val); + svraddhnb(svuint16_t_val, uint16_t_val); + svraddhnb(svuint32_t_val, svuint32_t_val); + svraddhnb(svuint32_t_val, uint32_t_val); + svraddhnb(svuint64_t_val, svuint64_t_val); + svraddhnb(svuint64_t_val, uint64_t_val); + svraddhnb_n_s16(svint16_t_val, int16_t_val); + svraddhnb_n_s32(svint32_t_val, int32_t_val); + svraddhnb_n_s64(svint64_t_val, int64_t_val); + svraddhnb_n_u16(svuint16_t_val, uint16_t_val); + svraddhnb_n_u32(svuint32_t_val, uint32_t_val); + svraddhnb_n_u64(svuint64_t_val, uint64_t_val); + svraddhnb_s16(svint16_t_val, svint16_t_val); + svraddhnb_s32(svint32_t_val, svint32_t_val); + svraddhnb_s64(svint64_t_val, svint64_t_val); + svraddhnb_u16(svuint16_t_val, svuint16_t_val); + svraddhnb_u32(svuint32_t_val, svuint32_t_val); + svraddhnb_u64(svuint64_t_val, svuint64_t_val); + svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_x(svbool_t_val, svuint32_t_val); + svrecpe_u32_z(svbool_t_val, svuint32_t_val); + svrecpe_x(svbool_t_val, svuint32_t_val); + svrecpe_z(svbool_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshr_m(svbool_t_val, svint8_t_val, 2); + svrshr_m(svbool_t_val, svint16_t_val, 2); + svrshr_m(svbool_t_val, svint32_t_val, 2); + svrshr_m(svbool_t_val, svint64_t_val, 2); + svrshr_m(svbool_t_val, svuint8_t_val, 2); + svrshr_m(svbool_t_val, svuint16_t_val, 2); + svrshr_m(svbool_t_val, svuint32_t_val, 2); + svrshr_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); + svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); + svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); + svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); + svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); + svrshr_x(svbool_t_val, svint8_t_val, 2); + svrshr_x(svbool_t_val, svint16_t_val, 2); + svrshr_x(svbool_t_val, svint32_t_val, 2); + svrshr_x(svbool_t_val, svint64_t_val, 2); + svrshr_x(svbool_t_val, svuint8_t_val, 2); + svrshr_x(svbool_t_val, svuint16_t_val, 2); + svrshr_x(svbool_t_val, svuint32_t_val, 2); + svrshr_x(svbool_t_val, svuint64_t_val, 2); + svrshr_z(svbool_t_val, svint8_t_val, 2); + svrshr_z(svbool_t_val, svint16_t_val, 2); + svrshr_z(svbool_t_val, svint32_t_val, 2); + svrshr_z(svbool_t_val, svint64_t_val, 2); + svrshr_z(svbool_t_val, svuint8_t_val, 2); + svrshr_z(svbool_t_val, svuint16_t_val, 2); + svrshr_z(svbool_t_val, svuint32_t_val, 2); + svrshr_z(svbool_t_val, svuint64_t_val, 2); + svrshrnb(svint16_t_val, 2); + svrshrnb(svint32_t_val, 2); + svrshrnb(svint64_t_val, 2); + svrshrnb(svuint16_t_val, 2); + svrshrnb(svuint32_t_val, 2); + svrshrnb(svuint64_t_val, 2); + svrshrnb_n_s16(svint16_t_val, 2); + svrshrnb_n_s32(svint32_t_val, 2); + svrshrnb_n_s64(svint64_t_val, 2); + svrshrnb_n_u16(svuint16_t_val, 2); + svrshrnb_n_u32(svuint32_t_val, 2); + svrshrnb_n_u64(svuint64_t_val, 2); + svrshrnt(svint8_t_val, svint16_t_val, 2); + svrshrnt(svint16_t_val, svint32_t_val, 2); + svrshrnt(svint32_t_val, svint64_t_val, 2); + svrshrnt(svuint8_t_val, svuint16_t_val, 2); + svrshrnt(svuint16_t_val, svuint32_t_val, 2); + svrshrnt(svuint32_t_val, svuint64_t_val, 2); + svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_x(svbool_t_val, svuint32_t_val); + svrsqrte_u32_z(svbool_t_val, svuint32_t_val); + svrsqrte_x(svbool_t_val, svuint32_t_val); + svrsqrte_z(svbool_t_val, svuint32_t_val); + svrsra(svint8_t_val, svint8_t_val, 2); + svrsra(svint16_t_val, svint16_t_val, 2); + svrsra(svint32_t_val, svint32_t_val, 2); + svrsra(svint64_t_val, svint64_t_val, 2); + svrsra(svuint8_t_val, svuint8_t_val, 2); + svrsra(svuint16_t_val, svuint16_t_val, 2); + svrsra(svuint32_t_val, svuint32_t_val, 2); + svrsra(svuint64_t_val, svuint64_t_val, 2); + svrsra_n_s8(svint8_t_val, svint8_t_val, 2); + svrsra_n_s16(svint16_t_val, svint16_t_val, 2); + svrsra_n_s32(svint32_t_val, svint32_t_val, 2); + svrsra_n_s64(svint64_t_val, svint64_t_val, 2); + svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svrsubhnb(svint16_t_val, int16_t_val); + svrsubhnb(svint16_t_val, svint16_t_val); + svrsubhnb(svint32_t_val, int32_t_val); + svrsubhnb(svint32_t_val, svint32_t_val); + svrsubhnb(svint64_t_val, int64_t_val); + svrsubhnb(svint64_t_val, svint64_t_val); + svrsubhnb(svuint16_t_val, svuint16_t_val); + svrsubhnb(svuint16_t_val, uint16_t_val); + svrsubhnb(svuint32_t_val, svuint32_t_val); + svrsubhnb(svuint32_t_val, uint32_t_val); + svrsubhnb(svuint64_t_val, svuint64_t_val); + svrsubhnb(svuint64_t_val, uint64_t_val); + svrsubhnb_n_s16(svint16_t_val, int16_t_val); + svrsubhnb_n_s32(svint32_t_val, int32_t_val); + svrsubhnb_n_s64(svint64_t_val, int64_t_val); + svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svrsubhnb_s16(svint16_t_val, svint16_t_val); + svrsubhnb_s32(svint32_t_val, svint32_t_val); + svrsubhnb_s64(svint64_t_val, svint64_t_val); + svrsubhnb_u16(svuint16_t_val, svuint16_t_val); + svrsubhnb_u32(svuint32_t_val, svuint32_t_val); + svrsubhnb_u64(svuint64_t_val, svuint64_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svshllb(svint8_t_val, 2); + svshllb(svint16_t_val, 2); + svshllb(svint32_t_val, 2); + svshllb(svuint8_t_val, 2); + svshllb(svuint16_t_val, 2); + svshllb(svuint32_t_val, 2); + svshllb_n_s16(svint8_t_val, 2); + svshllb_n_s32(svint16_t_val, 2); + svshllb_n_s64(svint32_t_val, 2); + svshllb_n_u16(svuint8_t_val, 2); + svshllb_n_u32(svuint16_t_val, 2); + svshllb_n_u64(svuint32_t_val, 2); + svshllt(svint8_t_val, 2); + svshllt(svint16_t_val, 2); + svshllt(svint32_t_val, 2); + svshllt(svuint8_t_val, 2); + svshllt(svuint16_t_val, 2); + svshllt(svuint32_t_val, 2); + svshllt_n_s16(svint8_t_val, 2); + svshllt_n_s32(svint16_t_val, 2); + svshllt_n_s64(svint32_t_val, 2); + svshllt_n_u16(svuint8_t_val, 2); + svshllt_n_u32(svuint16_t_val, 2); + svshllt_n_u64(svuint32_t_val, 2); + svshrnb(svint16_t_val, 2); + svshrnb(svint32_t_val, 2); + svshrnb(svint64_t_val, 2); + svshrnb(svuint16_t_val, 2); + svshrnb(svuint32_t_val, 2); + svshrnb(svuint64_t_val, 2); + svshrnb_n_s16(svint16_t_val, 2); + svshrnb_n_s32(svint32_t_val, 2); + svshrnb_n_s64(svint64_t_val, 2); + svshrnb_n_u16(svuint16_t_val, 2); + svshrnb_n_u32(svuint32_t_val, 2); + svshrnb_n_u64(svuint64_t_val, 2); + svshrnt(svint8_t_val, svint16_t_val, 2); + svshrnt(svint16_t_val, svint32_t_val, 2); + svshrnt(svint32_t_val, svint64_t_val, 2); + svshrnt(svuint8_t_val, svuint16_t_val, 2); + svshrnt(svuint16_t_val, svuint32_t_val, 2); + svshrnt(svuint32_t_val, svuint64_t_val, 2); + svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svsli(svint8_t_val, svint8_t_val, 2); + svsli(svint16_t_val, svint16_t_val, 2); + svsli(svint32_t_val, svint32_t_val, 2); + svsli(svint64_t_val, svint64_t_val, 2); + svsli(svuint8_t_val, svuint8_t_val, 2); + svsli(svuint16_t_val, svuint16_t_val, 2); + svsli(svuint32_t_val, svuint32_t_val, 2); + svsli(svuint64_t_val, svuint64_t_val, 2); + svsli_n_s8(svint8_t_val, svint8_t_val, 2); + svsli_n_s16(svint16_t_val, svint16_t_val, 2); + svsli_n_s32(svint32_t_val, svint32_t_val, 2); + svsli_n_s64(svint64_t_val, svint64_t_val, 2); + svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsra(svint8_t_val, svint8_t_val, 2); + svsra(svint16_t_val, svint16_t_val, 2); + svsra(svint32_t_val, svint32_t_val, 2); + svsra(svint64_t_val, svint64_t_val, 2); + svsra(svuint8_t_val, svuint8_t_val, 2); + svsra(svuint16_t_val, svuint16_t_val, 2); + svsra(svuint32_t_val, svuint32_t_val, 2); + svsra(svuint64_t_val, svuint64_t_val, 2); + svsra_n_s8(svint8_t_val, svint8_t_val, 2); + svsra_n_s16(svint16_t_val, svint16_t_val, 2); + svsra_n_s32(svint32_t_val, svint32_t_val, 2); + svsra_n_s64(svint64_t_val, svint64_t_val, 2); + svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsri(svint8_t_val, svint8_t_val, 2); + svsri(svint16_t_val, svint16_t_val, 2); + svsri(svint32_t_val, svint32_t_val, 2); + svsri(svint64_t_val, svint64_t_val, 2); + svsri(svuint8_t_val, svuint8_t_val, 2); + svsri(svuint16_t_val, svuint16_t_val, 2); + svsri(svuint32_t_val, svuint32_t_val, 2); + svsri(svuint64_t_val, svuint64_t_val, 2); + svsri_n_s8(svint8_t_val, svint8_t_val, 2); + svsri_n_s16(svint16_t_val, svint16_t_val, 2); + svsri_n_s32(svint32_t_val, svint32_t_val, 2); + svsri_n_s64(svint64_t_val, svint64_t_val, 2); + svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsubhnb(svint16_t_val, int16_t_val); + svsubhnb(svint16_t_val, svint16_t_val); + svsubhnb(svint32_t_val, int32_t_val); + svsubhnb(svint32_t_val, svint32_t_val); + svsubhnb(svint64_t_val, int64_t_val); + svsubhnb(svint64_t_val, svint64_t_val); + svsubhnb(svuint16_t_val, svuint16_t_val); + svsubhnb(svuint16_t_val, uint16_t_val); + svsubhnb(svuint32_t_val, svuint32_t_val); + svsubhnb(svuint32_t_val, uint32_t_val); + svsubhnb(svuint64_t_val, svuint64_t_val); + svsubhnb(svuint64_t_val, uint64_t_val); + svsubhnb_n_s16(svint16_t_val, int16_t_val); + svsubhnb_n_s32(svint32_t_val, int32_t_val); + svsubhnb_n_s64(svint64_t_val, int64_t_val); + svsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svsubhnb_s16(svint16_t_val, svint16_t_val); + svsubhnb_s32(svint32_t_val, svint32_t_val); + svsubhnb_s64(svint64_t_val, svint64_t_val); + svsubhnb_u16(svuint16_t_val, svuint16_t_val); + svsubhnb_u32(svuint32_t_val, svuint32_t_val); + svsubhnb_u64(svuint64_t_val, svuint64_t_val); + svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsublb(svint8_t_val, int8_t_val); + svsublb(svint8_t_val, svint8_t_val); + svsublb(svint16_t_val, int16_t_val); + svsublb(svint16_t_val, svint16_t_val); + svsublb(svint32_t_val, int32_t_val); + svsublb(svint32_t_val, svint32_t_val); + svsublb(svuint8_t_val, svuint8_t_val); + svsublb(svuint8_t_val, uint8_t_val); + svsublb(svuint16_t_val, svuint16_t_val); + svsublb(svuint16_t_val, uint16_t_val); + svsublb(svuint32_t_val, svuint32_t_val); + svsublb(svuint32_t_val, uint32_t_val); + svsublb_n_s16(svint8_t_val, int8_t_val); + svsublb_n_s32(svint16_t_val, int16_t_val); + svsublb_n_s64(svint32_t_val, int32_t_val); + svsublb_n_u16(svuint8_t_val, uint8_t_val); + svsublb_n_u32(svuint16_t_val, uint16_t_val); + svsublb_n_u64(svuint32_t_val, uint32_t_val); + svsublb_s16(svint8_t_val, svint8_t_val); + svsublb_s32(svint16_t_val, svint16_t_val); + svsublb_s64(svint32_t_val, svint32_t_val); + svsublb_u16(svuint8_t_val, svuint8_t_val); + svsublb_u32(svuint16_t_val, svuint16_t_val); + svsublb_u64(svuint32_t_val, svuint32_t_val); + svsublbt(svint8_t_val, int8_t_val); + svsublbt(svint8_t_val, svint8_t_val); + svsublbt(svint16_t_val, int16_t_val); + svsublbt(svint16_t_val, svint16_t_val); + svsublbt(svint32_t_val, int32_t_val); + svsublbt(svint32_t_val, svint32_t_val); + svsublbt_n_s16(svint8_t_val, int8_t_val); + svsublbt_n_s32(svint16_t_val, int16_t_val); + svsublbt_n_s64(svint32_t_val, int32_t_val); + svsublbt_s16(svint8_t_val, svint8_t_val); + svsublbt_s32(svint16_t_val, svint16_t_val); + svsublbt_s64(svint32_t_val, svint32_t_val); + svsublt(svint8_t_val, int8_t_val); + svsublt(svint8_t_val, svint8_t_val); + svsublt(svint16_t_val, int16_t_val); + svsublt(svint16_t_val, svint16_t_val); + svsublt(svint32_t_val, int32_t_val); + svsublt(svint32_t_val, svint32_t_val); + svsublt(svuint8_t_val, svuint8_t_val); + svsublt(svuint8_t_val, uint8_t_val); + svsublt(svuint16_t_val, svuint16_t_val); + svsublt(svuint16_t_val, uint16_t_val); + svsublt(svuint32_t_val, svuint32_t_val); + svsublt(svuint32_t_val, uint32_t_val); + svsublt_n_s16(svint8_t_val, int8_t_val); + svsublt_n_s32(svint16_t_val, int16_t_val); + svsublt_n_s64(svint32_t_val, int32_t_val); + svsublt_n_u16(svuint8_t_val, uint8_t_val); + svsublt_n_u32(svuint16_t_val, uint16_t_val); + svsublt_n_u64(svuint32_t_val, uint32_t_val); + svsublt_s16(svint8_t_val, svint8_t_val); + svsublt_s32(svint16_t_val, svint16_t_val); + svsublt_s64(svint32_t_val, svint32_t_val); + svsublt_u16(svuint8_t_val, svuint8_t_val); + svsublt_u32(svuint16_t_val, svuint16_t_val); + svsublt_u64(svuint32_t_val, svuint32_t_val); + svsubltb(svint8_t_val, int8_t_val); + svsubltb(svint8_t_val, svint8_t_val); + svsubltb(svint16_t_val, int16_t_val); + svsubltb(svint16_t_val, svint16_t_val); + svsubltb(svint32_t_val, int32_t_val); + svsubltb(svint32_t_val, svint32_t_val); + svsubltb_n_s16(svint8_t_val, int8_t_val); + svsubltb_n_s32(svint16_t_val, int16_t_val); + svsubltb_n_s64(svint32_t_val, int32_t_val); + svsubltb_s16(svint8_t_val, svint8_t_val); + svsubltb_s32(svint16_t_val, svint16_t_val); + svsubltb_s64(svint32_t_val, svint32_t_val); + svsubwb(svint16_t_val, int8_t_val); + svsubwb(svint16_t_val, svint8_t_val); + svsubwb(svint32_t_val, int16_t_val); + svsubwb(svint32_t_val, svint16_t_val); + svsubwb(svint64_t_val, int32_t_val); + svsubwb(svint64_t_val, svint32_t_val); + svsubwb(svuint16_t_val, svuint8_t_val); + svsubwb(svuint16_t_val, uint8_t_val); + svsubwb(svuint32_t_val, svuint16_t_val); + svsubwb(svuint32_t_val, uint16_t_val); + svsubwb(svuint64_t_val, svuint32_t_val); + svsubwb(svuint64_t_val, uint32_t_val); + svsubwb_n_s16(svint16_t_val, int8_t_val); + svsubwb_n_s32(svint32_t_val, int16_t_val); + svsubwb_n_s64(svint64_t_val, int32_t_val); + svsubwb_n_u16(svuint16_t_val, uint8_t_val); + svsubwb_n_u32(svuint32_t_val, uint16_t_val); + svsubwb_n_u64(svuint64_t_val, uint32_t_val); + svsubwb_s16(svint16_t_val, svint8_t_val); + svsubwb_s32(svint32_t_val, svint16_t_val); + svsubwb_s64(svint64_t_val, svint32_t_val); + svsubwb_u16(svuint16_t_val, svuint8_t_val); + svsubwb_u32(svuint32_t_val, svuint16_t_val); + svsubwb_u64(svuint64_t_val, svuint32_t_val); + svsubwt(svint16_t_val, int8_t_val); + svsubwt(svint16_t_val, svint8_t_val); + svsubwt(svint32_t_val, int16_t_val); + svsubwt(svint32_t_val, svint16_t_val); + svsubwt(svint64_t_val, int32_t_val); + svsubwt(svint64_t_val, svint32_t_val); + svsubwt(svuint16_t_val, svuint8_t_val); + svsubwt(svuint16_t_val, uint8_t_val); + svsubwt(svuint32_t_val, svuint16_t_val); + svsubwt(svuint32_t_val, uint16_t_val); + svsubwt(svuint64_t_val, svuint32_t_val); + svsubwt(svuint64_t_val, uint32_t_val); + svsubwt_n_s16(svint16_t_val, int8_t_val); + svsubwt_n_s32(svint32_t_val, int16_t_val); + svsubwt_n_s64(svint64_t_val, int32_t_val); + svsubwt_n_u16(svuint16_t_val, uint8_t_val); + svsubwt_n_u32(svuint32_t_val, uint16_t_val); + svsubwt_n_u64(svuint64_t_val, uint32_t_val); + svsubwt_s16(svint16_t_val, svint8_t_val); + svsubwt_s32(svint32_t_val, svint16_t_val); + svsubwt_s64(svint64_t_val, svint32_t_val); + svsubwt_u16(svuint16_t_val, svuint8_t_val); + svsubwt_u32(svuint32_t_val, svuint16_t_val); + svsubwt_u64(svuint64_t_val, svuint32_t_val); + svtbl2(svbfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat32x2_t_val, svuint32_t_val); + svtbl2(svfloat64x2_t_val, svuint64_t_val); + svtbl2(svint8x2_t_val, svuint8_t_val); + svtbl2(svint16x2_t_val, svuint16_t_val); + svtbl2(svint32x2_t_val, svuint32_t_val); + svtbl2(svint64x2_t_val, svuint64_t_val); + svtbl2(svuint8x2_t_val, svuint8_t_val); + svtbl2(svuint16x2_t_val, svuint16_t_val); + svtbl2(svuint32x2_t_val, svuint32_t_val); + svtbl2(svuint64x2_t_val, svuint64_t_val); + svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); + svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); + svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); + svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); + svtbl2_s8(svint8x2_t_val, svuint8_t_val); + svtbl2_s16(svint16x2_t_val, svuint16_t_val); + svtbl2_s32(svint32x2_t_val, svuint32_t_val); + svtbl2_s64(svint64x2_t_val, svuint64_t_val); + svtbl2_u8(svuint8x2_t_val, svuint8_t_val); + svtbl2_u16(svuint16x2_t_val, svuint16_t_val); + svtbl2_u32(svuint32x2_t_val, svuint32_t_val); + svtbl2_u64(svuint64x2_t_val, svuint64_t_val); + svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); + svwhilege_b8(int32_t_val, int32_t_val); + svwhilege_b8(int64_t_val, int64_t_val); + svwhilege_b8(uint32_t_val, uint32_t_val); + svwhilege_b8(uint64_t_val, uint64_t_val); + svwhilege_b8_s32(int32_t_val, int32_t_val); + svwhilege_b8_s64(int64_t_val, int64_t_val); + svwhilege_b8_u32(uint32_t_val, uint32_t_val); + svwhilege_b8_u64(uint64_t_val, uint64_t_val); + svwhilege_b16(int32_t_val, int32_t_val); + svwhilege_b16(int64_t_val, int64_t_val); + svwhilege_b16(uint32_t_val, uint32_t_val); + svwhilege_b16(uint64_t_val, uint64_t_val); + svwhilege_b16_s32(int32_t_val, int32_t_val); + svwhilege_b16_s64(int64_t_val, int64_t_val); + svwhilege_b16_u32(uint32_t_val, uint32_t_val); + svwhilege_b16_u64(uint64_t_val, uint64_t_val); + svwhilege_b32(int32_t_val, int32_t_val); + svwhilege_b32(int64_t_val, int64_t_val); + svwhilege_b32(uint32_t_val, uint32_t_val); + svwhilege_b32(uint64_t_val, uint64_t_val); + svwhilege_b32_s32(int32_t_val, int32_t_val); + svwhilege_b32_s64(int64_t_val, int64_t_val); + svwhilege_b32_u32(uint32_t_val, uint32_t_val); + svwhilege_b32_u64(uint64_t_val, uint64_t_val); + svwhilege_b64(int32_t_val, int32_t_val); + svwhilege_b64(int64_t_val, int64_t_val); + svwhilege_b64(uint32_t_val, uint32_t_val); + svwhilege_b64(uint64_t_val, uint64_t_val); + svwhilege_b64_s32(int32_t_val, int32_t_val); + svwhilege_b64_s64(int64_t_val, int64_t_val); + svwhilege_b64_u32(uint32_t_val, uint32_t_val); + svwhilege_b64_u64(uint64_t_val, uint64_t_val); + svwhilegt_b8(int32_t_val, int32_t_val); + svwhilegt_b8(int64_t_val, int64_t_val); + svwhilegt_b8(uint32_t_val, uint32_t_val); + svwhilegt_b8(uint64_t_val, uint64_t_val); + svwhilegt_b8_s32(int32_t_val, int32_t_val); + svwhilegt_b8_s64(int64_t_val, int64_t_val); + svwhilegt_b8_u32(uint32_t_val, uint32_t_val); + svwhilegt_b8_u64(uint64_t_val, uint64_t_val); + svwhilegt_b16(int32_t_val, int32_t_val); + svwhilegt_b16(int64_t_val, int64_t_val); + svwhilegt_b16(uint32_t_val, uint32_t_val); + svwhilegt_b16(uint64_t_val, uint64_t_val); + svwhilegt_b16_s32(int32_t_val, int32_t_val); + svwhilegt_b16_s64(int64_t_val, int64_t_val); + svwhilegt_b16_u32(uint32_t_val, uint32_t_val); + svwhilegt_b16_u64(uint64_t_val, uint64_t_val); + svwhilegt_b32(int32_t_val, int32_t_val); + svwhilegt_b32(int64_t_val, int64_t_val); + svwhilegt_b32(uint32_t_val, uint32_t_val); + svwhilegt_b32(uint64_t_val, uint64_t_val); + svwhilegt_b32_s32(int32_t_val, int32_t_val); + svwhilegt_b32_s64(int64_t_val, int64_t_val); + svwhilegt_b32_u32(uint32_t_val, uint32_t_val); + svwhilegt_b32_u64(uint64_t_val, uint64_t_val); + svwhilegt_b64(int32_t_val, int32_t_val); + svwhilegt_b64(int64_t_val, int64_t_val); + svwhilegt_b64(uint32_t_val, uint32_t_val); + svwhilegt_b64(uint64_t_val, uint64_t_val); + svwhilegt_b64_s32(int32_t_val, int32_t_val); + svwhilegt_b64_s64(int64_t_val, int64_t_val); + svwhilegt_b64_u32(uint32_t_val, uint32_t_val); + svwhilegt_b64_u64(uint64_t_val, uint64_t_val); + svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svxar(svint8_t_val, svint8_t_val, 2); + svxar(svint16_t_val, svint16_t_val, 2); + svxar(svint32_t_val, svint32_t_val, 2); + svxar(svint64_t_val, svint64_t_val, 2); + svxar(svuint8_t_val, svuint8_t_val, 2); + svxar(svuint16_t_val, svuint16_t_val, 2); + svxar(svuint32_t_val, svuint32_t_val, 2); + svxar(svuint64_t_val, svuint64_t_val, 2); + svxar_n_s8(svint8_t_val, svint8_t_val, 2); + svxar_n_s16(svint16_t_val, svint16_t_val, 2); + svxar_n_s32(svint32_t_val, svint32_t_val, 2); + svxar_n_s64(svint64_t_val, svint64_t_val, 2); + svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); + svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); + svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); + svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + svaba(svint8_t_val, svint8_t_val, int8_t_val); + svaba(svint8_t_val, svint8_t_val, svint8_t_val); + svaba(svint16_t_val, svint16_t_val, int16_t_val); + svaba(svint16_t_val, svint16_t_val, svint16_t_val); + svaba(svint32_t_val, svint32_t_val, int32_t_val); + svaba(svint32_t_val, svint32_t_val, svint32_t_val); + svaba(svint64_t_val, svint64_t_val, int64_t_val); + svaba(svint64_t_val, svint64_t_val, svint64_t_val); + svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svabalb(svint16_t_val, svint8_t_val, int8_t_val); + svabalb(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb(svint32_t_val, svint16_t_val, int16_t_val); + svabalb(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb(svint64_t_val, svint32_t_val, int32_t_val); + svabalb(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svint16_t_val, svint8_t_val, int8_t_val); + svabalt(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt(svint32_t_val, svint16_t_val, int16_t_val); + svabalt(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt(svint64_t_val, svint32_t_val, int32_t_val); + svabalt(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabdlb(svint8_t_val, int8_t_val); + svabdlb(svint8_t_val, svint8_t_val); + svabdlb(svint16_t_val, int16_t_val); + svabdlb(svint16_t_val, svint16_t_val); + svabdlb(svint32_t_val, int32_t_val); + svabdlb(svint32_t_val, svint32_t_val); + svabdlb(svuint8_t_val, svuint8_t_val); + svabdlb(svuint8_t_val, uint8_t_val); + svabdlb(svuint16_t_val, svuint16_t_val); + svabdlb(svuint16_t_val, uint16_t_val); + svabdlb(svuint32_t_val, svuint32_t_val); + svabdlb(svuint32_t_val, uint32_t_val); + svabdlb_n_s16(svint8_t_val, int8_t_val); + svabdlb_n_s32(svint16_t_val, int16_t_val); + svabdlb_n_s64(svint32_t_val, int32_t_val); + svabdlb_n_u16(svuint8_t_val, uint8_t_val); + svabdlb_n_u32(svuint16_t_val, uint16_t_val); + svabdlb_n_u64(svuint32_t_val, uint32_t_val); + svabdlb_s16(svint8_t_val, svint8_t_val); + svabdlb_s32(svint16_t_val, svint16_t_val); + svabdlb_s64(svint32_t_val, svint32_t_val); + svabdlb_u16(svuint8_t_val, svuint8_t_val); + svabdlb_u32(svuint16_t_val, svuint16_t_val); + svabdlb_u64(svuint32_t_val, svuint32_t_val); + svabdlt(svint8_t_val, int8_t_val); + svabdlt(svint8_t_val, svint8_t_val); + svabdlt(svint16_t_val, int16_t_val); + svabdlt(svint16_t_val, svint16_t_val); + svabdlt(svint32_t_val, int32_t_val); + svabdlt(svint32_t_val, svint32_t_val); + svabdlt(svuint8_t_val, svuint8_t_val); + svabdlt(svuint8_t_val, uint8_t_val); + svabdlt(svuint16_t_val, svuint16_t_val); + svabdlt(svuint16_t_val, uint16_t_val); + svabdlt(svuint32_t_val, svuint32_t_val); + svabdlt(svuint32_t_val, uint32_t_val); + svabdlt_n_s16(svint8_t_val, int8_t_val); + svabdlt_n_s32(svint16_t_val, int16_t_val); + svabdlt_n_s64(svint32_t_val, int32_t_val); + svabdlt_n_u16(svuint8_t_val, uint8_t_val); + svabdlt_n_u32(svuint16_t_val, uint16_t_val); + svabdlt_n_u64(svuint32_t_val, uint32_t_val); + svabdlt_s16(svint8_t_val, svint8_t_val); + svabdlt_s32(svint16_t_val, svint16_t_val); + svabdlt_s64(svint32_t_val, svint32_t_val); + svabdlt_u16(svuint8_t_val, svuint8_t_val); + svabdlt_u32(svuint16_t_val, svuint16_t_val); + svabdlt_u64(svuint32_t_val, svuint32_t_val); + svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaddhnb(svint16_t_val, int16_t_val); + svaddhnb(svint16_t_val, svint16_t_val); + svaddhnb(svint32_t_val, int32_t_val); + svaddhnb(svint32_t_val, svint32_t_val); + svaddhnb(svint64_t_val, int64_t_val); + svaddhnb(svint64_t_val, svint64_t_val); + svaddhnb(svuint16_t_val, svuint16_t_val); + svaddhnb(svuint16_t_val, uint16_t_val); + svaddhnb(svuint32_t_val, svuint32_t_val); + svaddhnb(svuint32_t_val, uint32_t_val); + svaddhnb(svuint64_t_val, svuint64_t_val); + svaddhnb(svuint64_t_val, uint64_t_val); + svaddhnb_n_s16(svint16_t_val, int16_t_val); + svaddhnb_n_s32(svint32_t_val, int32_t_val); + svaddhnb_n_s64(svint64_t_val, int64_t_val); + svaddhnb_n_u16(svuint16_t_val, uint16_t_val); + svaddhnb_n_u32(svuint32_t_val, uint32_t_val); + svaddhnb_n_u64(svuint64_t_val, uint64_t_val); + svaddhnb_s16(svint16_t_val, svint16_t_val); + svaddhnb_s32(svint32_t_val, svint32_t_val); + svaddhnb_s64(svint64_t_val, svint64_t_val); + svaddhnb_u16(svuint16_t_val, svuint16_t_val); + svaddhnb_u32(svuint32_t_val, svuint32_t_val); + svaddhnb_u64(svuint64_t_val, svuint64_t_val); + svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddlb(svint8_t_val, int8_t_val); + svaddlb(svint8_t_val, svint8_t_val); + svaddlb(svint16_t_val, int16_t_val); + svaddlb(svint16_t_val, svint16_t_val); + svaddlb(svint32_t_val, int32_t_val); + svaddlb(svint32_t_val, svint32_t_val); + svaddlb(svuint8_t_val, svuint8_t_val); + svaddlb(svuint8_t_val, uint8_t_val); + svaddlb(svuint16_t_val, svuint16_t_val); + svaddlb(svuint16_t_val, uint16_t_val); + svaddlb(svuint32_t_val, svuint32_t_val); + svaddlb(svuint32_t_val, uint32_t_val); + svaddlb_n_s16(svint8_t_val, int8_t_val); + svaddlb_n_s32(svint16_t_val, int16_t_val); + svaddlb_n_s64(svint32_t_val, int32_t_val); + svaddlb_n_u16(svuint8_t_val, uint8_t_val); + svaddlb_n_u32(svuint16_t_val, uint16_t_val); + svaddlb_n_u64(svuint32_t_val, uint32_t_val); + svaddlb_s16(svint8_t_val, svint8_t_val); + svaddlb_s32(svint16_t_val, svint16_t_val); + svaddlb_s64(svint32_t_val, svint32_t_val); + svaddlb_u16(svuint8_t_val, svuint8_t_val); + svaddlb_u32(svuint16_t_val, svuint16_t_val); + svaddlb_u64(svuint32_t_val, svuint32_t_val); + svaddlbt(svint8_t_val, int8_t_val); + svaddlbt(svint8_t_val, svint8_t_val); + svaddlbt(svint16_t_val, int16_t_val); + svaddlbt(svint16_t_val, svint16_t_val); + svaddlbt(svint32_t_val, int32_t_val); + svaddlbt(svint32_t_val, svint32_t_val); + svaddlbt_n_s16(svint8_t_val, int8_t_val); + svaddlbt_n_s32(svint16_t_val, int16_t_val); + svaddlbt_n_s64(svint32_t_val, int32_t_val); + svaddlbt_s16(svint8_t_val, svint8_t_val); + svaddlbt_s32(svint16_t_val, svint16_t_val); + svaddlbt_s64(svint32_t_val, svint32_t_val); + svaddlt(svint8_t_val, int8_t_val); + svaddlt(svint8_t_val, svint8_t_val); + svaddlt(svint16_t_val, int16_t_val); + svaddlt(svint16_t_val, svint16_t_val); + svaddlt(svint32_t_val, int32_t_val); + svaddlt(svint32_t_val, svint32_t_val); + svaddlt(svuint8_t_val, svuint8_t_val); + svaddlt(svuint8_t_val, uint8_t_val); + svaddlt(svuint16_t_val, svuint16_t_val); + svaddlt(svuint16_t_val, uint16_t_val); + svaddlt(svuint32_t_val, svuint32_t_val); + svaddlt(svuint32_t_val, uint32_t_val); + svaddlt_n_s16(svint8_t_val, int8_t_val); + svaddlt_n_s32(svint16_t_val, int16_t_val); + svaddlt_n_s64(svint32_t_val, int32_t_val); + svaddlt_n_u16(svuint8_t_val, uint8_t_val); + svaddlt_n_u32(svuint16_t_val, uint16_t_val); + svaddlt_n_u64(svuint32_t_val, uint32_t_val); + svaddlt_s16(svint8_t_val, svint8_t_val); + svaddlt_s32(svint16_t_val, svint16_t_val); + svaddlt_s64(svint32_t_val, svint32_t_val); + svaddlt_u16(svuint8_t_val, svuint8_t_val); + svaddlt_u32(svuint16_t_val, svuint16_t_val); + svaddlt_u64(svuint32_t_val, svuint32_t_val); + svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddwb(svint16_t_val, int8_t_val); + svaddwb(svint16_t_val, svint8_t_val); + svaddwb(svint32_t_val, int16_t_val); + svaddwb(svint32_t_val, svint16_t_val); + svaddwb(svint64_t_val, int32_t_val); + svaddwb(svint64_t_val, svint32_t_val); + svaddwb(svuint16_t_val, svuint8_t_val); + svaddwb(svuint16_t_val, uint8_t_val); + svaddwb(svuint32_t_val, svuint16_t_val); + svaddwb(svuint32_t_val, uint16_t_val); + svaddwb(svuint64_t_val, svuint32_t_val); + svaddwb(svuint64_t_val, uint32_t_val); + svaddwb_n_s16(svint16_t_val, int8_t_val); + svaddwb_n_s32(svint32_t_val, int16_t_val); + svaddwb_n_s64(svint64_t_val, int32_t_val); + svaddwb_n_u16(svuint16_t_val, uint8_t_val); + svaddwb_n_u32(svuint32_t_val, uint16_t_val); + svaddwb_n_u64(svuint64_t_val, uint32_t_val); + svaddwb_s16(svint16_t_val, svint8_t_val); + svaddwb_s32(svint32_t_val, svint16_t_val); + svaddwb_s64(svint64_t_val, svint32_t_val); + svaddwb_u16(svuint16_t_val, svuint8_t_val); + svaddwb_u32(svuint32_t_val, svuint16_t_val); + svaddwb_u64(svuint64_t_val, svuint32_t_val); + svaddwt(svint16_t_val, int8_t_val); + svaddwt(svint16_t_val, svint8_t_val); + svaddwt(svint32_t_val, int16_t_val); + svaddwt(svint32_t_val, svint16_t_val); + svaddwt(svint64_t_val, int32_t_val); + svaddwt(svint64_t_val, svint32_t_val); + svaddwt(svuint16_t_val, svuint8_t_val); + svaddwt(svuint16_t_val, uint8_t_val); + svaddwt(svuint32_t_val, svuint16_t_val); + svaddwt(svuint32_t_val, uint16_t_val); + svaddwt(svuint64_t_val, svuint32_t_val); + svaddwt(svuint64_t_val, uint32_t_val); + svaddwt_n_s16(svint16_t_val, int8_t_val); + svaddwt_n_s32(svint32_t_val, int16_t_val); + svaddwt_n_s64(svint64_t_val, int32_t_val); + svaddwt_n_u16(svuint16_t_val, uint8_t_val); + svaddwt_n_u32(svuint32_t_val, uint16_t_val); + svaddwt_n_u64(svuint64_t_val, uint32_t_val); + svaddwt_s16(svint16_t_val, svint8_t_val); + svaddwt_s32(svint32_t_val, svint16_t_val); + svaddwt_s64(svint64_t_val, svint32_t_val); + svaddwt_u16(svuint16_t_val, svuint8_t_val); + svaddwt_u32(svuint32_t_val, svuint16_t_val); + svaddwt_u64(svuint64_t_val, svuint32_t_val); + svbcax(svint8_t_val, svint8_t_val, int8_t_val); + svbcax(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax(svint16_t_val, svint16_t_val, int16_t_val); + svbcax(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax(svint32_t_val, svint32_t_val, int32_t_val); + svbcax(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax(svint64_t_val, svint64_t_val, int64_t_val); + svbcax(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svint8_t_val, svint8_t_val, int8_t_val); + svbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl(svint16_t_val, svint16_t_val, int16_t_val); + svbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl(svint32_t_val, svint32_t_val, int32_t_val); + svbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl(svint64_t_val, svint64_t_val, int64_t_val); + svbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcadd(svint8_t_val, svint8_t_val, 90); + svcadd(svint16_t_val, svint16_t_val, 90); + svcadd(svint32_t_val, svint32_t_val, 90); + svcadd(svint64_t_val, svint64_t_val, 90); + svcadd(svuint8_t_val, svuint8_t_val, 90); + svcadd(svuint16_t_val, svuint16_t_val, 90); + svcadd(svuint32_t_val, svuint32_t_val, 90); + svcadd(svuint64_t_val, svuint64_t_val, 90); + svcadd_s8(svint8_t_val, svint8_t_val, 90); + svcadd_s16(svint16_t_val, svint16_t_val, 90); + svcadd_s32(svint32_t_val, svint32_t_val, 90); + svcadd_s64(svint64_t_val, svint64_t_val, 90); + svcadd_u8(svuint8_t_val, svuint8_t_val, 90); + svcadd_u16(svuint16_t_val, svuint16_t_val, 90); + svcadd_u32(svuint32_t_val, svuint32_t_val, 90); + svcadd_u64(svuint64_t_val, svuint64_t_val, 90); + svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); + svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_z(svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + sveor3(svint8_t_val, svint8_t_val, int8_t_val); + sveor3(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3(svint16_t_val, svint16_t_val, int16_t_val); + sveor3(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3(svint32_t_val, svint32_t_val, int32_t_val); + sveor3(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3(svint64_t_val, svint64_t_val, int64_t_val); + sveor3(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svint8_t_val, svint8_t_val, int8_t_val); + sveortb(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb(svint16_t_val, svint16_t_val, int16_t_val); + sveortb(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb(svint32_t_val, svint32_t_val, int32_t_val); + sveortb(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb(svint64_t_val, svint64_t_val, int64_t_val); + sveortb(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_f16_x(svbool_t_val, svfloat16_t_val); + svlogb_f16_z(svbool_t_val, svfloat16_t_val); + svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_f32_x(svbool_t_val, svfloat32_t_val); + svlogb_f32_z(svbool_t_val, svfloat32_t_val); + svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_f64_x(svbool_t_val, svfloat64_t_val); + svlogb_f64_z(svbool_t_val, svfloat64_t_val); + svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_x(svbool_t_val, svfloat16_t_val); + svlogb_x(svbool_t_val, svfloat32_t_val); + svlogb_x(svbool_t_val, svfloat64_t_val); + svlogb_z(svbool_t_val, svfloat16_t_val); + svlogb_z(svbool_t_val, svfloat32_t_val); + svlogb_z(svbool_t_val, svfloat64_t_val); + svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmovlb(svint8_t_val); + svmovlb(svint16_t_val); + svmovlb(svint32_t_val); + svmovlb(svuint8_t_val); + svmovlb(svuint16_t_val); + svmovlb(svuint32_t_val); + svmovlb_s16(svint8_t_val); + svmovlb_s32(svint16_t_val); + svmovlb_s64(svint32_t_val); + svmovlb_u16(svuint8_t_val); + svmovlb_u32(svuint16_t_val); + svmovlb_u64(svuint32_t_val); + svmovlt(svint8_t_val); + svmovlt(svint16_t_val); + svmovlt(svint32_t_val); + svmovlt(svuint8_t_val); + svmovlt(svuint16_t_val); + svmovlt(svuint32_t_val); + svmovlt_s16(svint8_t_val); + svmovlt_s32(svint16_t_val); + svmovlt_s64(svint32_t_val); + svmovlt_u16(svuint8_t_val); + svmovlt_u32(svuint16_t_val); + svmovlt_u64(svuint32_t_val); + svmul_lane(svint16_t_val, svint16_t_val, 1); + svmul_lane(svint32_t_val, svint32_t_val, 1); + svmul_lane(svint64_t_val, svint64_t_val, 1); + svmul_lane(svuint16_t_val, svuint16_t_val, 1); + svmul_lane(svuint32_t_val, svuint32_t_val, 1); + svmul_lane(svuint64_t_val, svuint64_t_val, 1); + svmul_lane_s16(svint16_t_val, svint16_t_val, 1); + svmul_lane_s32(svint32_t_val, svint32_t_val, 1); + svmul_lane_s64(svint64_t_val, svint64_t_val, 1); + svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); + svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); + svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); + svmullb(svint8_t_val, int8_t_val); + svmullb(svint8_t_val, svint8_t_val); + svmullb(svint16_t_val, int16_t_val); + svmullb(svint16_t_val, svint16_t_val); + svmullb(svint32_t_val, int32_t_val); + svmullb(svint32_t_val, svint32_t_val); + svmullb(svuint8_t_val, svuint8_t_val); + svmullb(svuint8_t_val, uint8_t_val); + svmullb(svuint16_t_val, svuint16_t_val); + svmullb(svuint16_t_val, uint16_t_val); + svmullb(svuint32_t_val, svuint32_t_val); + svmullb(svuint32_t_val, uint32_t_val); + svmullb_lane(svint16_t_val, svint16_t_val, 1); + svmullb_lane(svint32_t_val, svint32_t_val, 1); + svmullb_lane(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane(svuint32_t_val, svuint32_t_val, 1); + svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullb_n_s16(svint8_t_val, int8_t_val); + svmullb_n_s32(svint16_t_val, int16_t_val); + svmullb_n_s64(svint32_t_val, int32_t_val); + svmullb_n_u16(svuint8_t_val, uint8_t_val); + svmullb_n_u32(svuint16_t_val, uint16_t_val); + svmullb_n_u64(svuint32_t_val, uint32_t_val); + svmullb_s16(svint8_t_val, svint8_t_val); + svmullb_s32(svint16_t_val, svint16_t_val); + svmullb_s64(svint32_t_val, svint32_t_val); + svmullb_u16(svuint8_t_val, svuint8_t_val); + svmullb_u32(svuint16_t_val, svuint16_t_val); + svmullb_u64(svuint32_t_val, svuint32_t_val); + svmullt(svint8_t_val, int8_t_val); + svmullt(svint8_t_val, svint8_t_val); + svmullt(svint16_t_val, int16_t_val); + svmullt(svint16_t_val, svint16_t_val); + svmullt(svint32_t_val, int32_t_val); + svmullt(svint32_t_val, svint32_t_val); + svmullt(svuint8_t_val, svuint8_t_val); + svmullt(svuint8_t_val, uint8_t_val); + svmullt(svuint16_t_val, svuint16_t_val); + svmullt(svuint16_t_val, uint16_t_val); + svmullt(svuint32_t_val, svuint32_t_val); + svmullt(svuint32_t_val, uint32_t_val); + svmullt_lane(svint16_t_val, svint16_t_val, 1); + svmullt_lane(svint32_t_val, svint32_t_val, 1); + svmullt_lane(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane(svuint32_t_val, svuint32_t_val, 1); + svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullt_n_s16(svint8_t_val, int8_t_val); + svmullt_n_s32(svint16_t_val, int16_t_val); + svmullt_n_s64(svint32_t_val, int32_t_val); + svmullt_n_u16(svuint8_t_val, uint8_t_val); + svmullt_n_u32(svuint16_t_val, uint16_t_val); + svmullt_n_u64(svuint32_t_val, uint32_t_val); + svmullt_s16(svint8_t_val, svint8_t_val); + svmullt_s32(svint16_t_val, svint16_t_val); + svmullt_s64(svint32_t_val, svint32_t_val); + svmullt_u16(svuint8_t_val, svuint8_t_val); + svmullt_u32(svuint16_t_val, svuint16_t_val); + svmullt_u64(svuint32_t_val, svuint32_t_val); + svnbsl(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpmul(svuint8_t_val, svuint8_t_val); + svpmul(svuint8_t_val, uint8_t_val); + svpmul_n_u8(svuint8_t_val, uint8_t_val); + svpmul_u8(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, uint8_t_val); + svpmullb(svuint32_t_val, svuint32_t_val); + svpmullb(svuint32_t_val, uint32_t_val); + svpmullb_n_u16(svuint8_t_val, uint8_t_val); + svpmullb_n_u64(svuint32_t_val, uint32_t_val); + svpmullb_pair(svuint8_t_val, svuint8_t_val); + svpmullb_pair(svuint8_t_val, uint8_t_val); + svpmullb_pair(svuint32_t_val, svuint32_t_val); + svpmullb_pair(svuint32_t_val, uint32_t_val); + svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullb_u16(svuint8_t_val, svuint8_t_val); + svpmullb_u64(svuint32_t_val, svuint32_t_val); + svpmullt(svuint8_t_val, svuint8_t_val); + svpmullt(svuint8_t_val, uint8_t_val); + svpmullt(svuint32_t_val, svuint32_t_val); + svpmullt(svuint32_t_val, uint32_t_val); + svpmullt_n_u16(svuint8_t_val, uint8_t_val); + svpmullt_n_u64(svuint32_t_val, uint32_t_val); + svpmullt_pair(svuint8_t_val, svuint8_t_val); + svpmullt_pair(svuint8_t_val, uint8_t_val); + svpmullt_pair(svuint32_t_val, svuint32_t_val); + svpmullt_pair(svuint32_t_val, uint32_t_val); + svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullt_u16(svuint8_t_val, svuint8_t_val); + svpmullt_u64(svuint32_t_val, svuint32_t_val); + svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_s8_x(svbool_t_val, svint8_t_val); + svqabs_s8_z(svbool_t_val, svint8_t_val); + svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_s16_x(svbool_t_val, svint16_t_val); + svqabs_s16_z(svbool_t_val, svint16_t_val); + svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_s32_x(svbool_t_val, svint32_t_val); + svqabs_s32_z(svbool_t_val, svint32_t_val); + svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s64_x(svbool_t_val, svint64_t_val); + svqabs_s64_z(svbool_t_val, svint64_t_val); + svqabs_x(svbool_t_val, svint8_t_val); + svqabs_x(svbool_t_val, svint16_t_val); + svqabs_x(svbool_t_val, svint32_t_val); + svqabs_x(svbool_t_val, svint64_t_val); + svqabs_z(svbool_t_val, svint8_t_val); + svqabs_z(svbool_t_val, svint16_t_val); + svqabs_z(svbool_t_val, svint32_t_val); + svqabs_z(svbool_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqcadd(svint8_t_val, svint8_t_val, 90); + svqcadd(svint16_t_val, svint16_t_val, 90); + svqcadd(svint32_t_val, svint32_t_val, 90); + svqcadd(svint64_t_val, svint64_t_val, 90); + svqcadd_s8(svint8_t_val, svint8_t_val, 90); + svqcadd_s16(svint16_t_val, svint16_t_val, 90); + svqcadd_s32(svint32_t_val, svint32_t_val, 90); + svqcadd_s64(svint64_t_val, svint64_t_val, 90); + svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmulh(svint8_t_val, int8_t_val); + svqdmulh(svint8_t_val, svint8_t_val); + svqdmulh(svint16_t_val, int16_t_val); + svqdmulh(svint16_t_val, svint16_t_val); + svqdmulh(svint32_t_val, int32_t_val); + svqdmulh(svint32_t_val, svint32_t_val); + svqdmulh(svint64_t_val, int64_t_val); + svqdmulh(svint64_t_val, svint64_t_val); + svqdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqdmulh_n_s8(svint8_t_val, int8_t_val); + svqdmulh_n_s16(svint16_t_val, int16_t_val); + svqdmulh_n_s32(svint32_t_val, int32_t_val); + svqdmulh_n_s64(svint64_t_val, int64_t_val); + svqdmulh_s8(svint8_t_val, svint8_t_val); + svqdmulh_s16(svint16_t_val, svint16_t_val); + svqdmulh_s32(svint32_t_val, svint32_t_val); + svqdmulh_s64(svint64_t_val, svint64_t_val); + svqdmullb(svint8_t_val, int8_t_val); + svqdmullb(svint8_t_val, svint8_t_val); + svqdmullb(svint16_t_val, int16_t_val); + svqdmullb(svint16_t_val, svint16_t_val); + svqdmullb(svint32_t_val, int32_t_val); + svqdmullb(svint32_t_val, svint32_t_val); + svqdmullb_lane(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane(svint32_t_val, svint32_t_val, 1); + svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullb_n_s16(svint8_t_val, int8_t_val); + svqdmullb_n_s32(svint16_t_val, int16_t_val); + svqdmullb_n_s64(svint32_t_val, int32_t_val); + svqdmullb_s16(svint8_t_val, svint8_t_val); + svqdmullb_s32(svint16_t_val, svint16_t_val); + svqdmullb_s64(svint32_t_val, svint32_t_val); + svqdmullt(svint8_t_val, int8_t_val); + svqdmullt(svint8_t_val, svint8_t_val); + svqdmullt(svint16_t_val, int16_t_val); + svqdmullt(svint16_t_val, svint16_t_val); + svqdmullt(svint32_t_val, int32_t_val); + svqdmullt(svint32_t_val, svint32_t_val); + svqdmullt_lane(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane(svint32_t_val, svint32_t_val, 1); + svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullt_n_s16(svint8_t_val, int8_t_val); + svqdmullt_n_s32(svint16_t_val, int16_t_val); + svqdmullt_n_s64(svint32_t_val, int32_t_val); + svqdmullt_s16(svint8_t_val, svint8_t_val); + svqdmullt_s32(svint16_t_val, svint16_t_val); + svqdmullt_s64(svint32_t_val, svint32_t_val); + svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_s8_x(svbool_t_val, svint8_t_val); + svqneg_s8_z(svbool_t_val, svint8_t_val); + svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_s16_x(svbool_t_val, svint16_t_val); + svqneg_s16_z(svbool_t_val, svint16_t_val); + svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_s32_x(svbool_t_val, svint32_t_val); + svqneg_s32_z(svbool_t_val, svint32_t_val); + svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s64_x(svbool_t_val, svint64_t_val); + svqneg_s64_z(svbool_t_val, svint64_t_val); + svqneg_x(svbool_t_val, svint8_t_val); + svqneg_x(svbool_t_val, svint16_t_val); + svqneg_x(svbool_t_val, svint32_t_val); + svqneg_x(svbool_t_val, svint64_t_val); + svqneg_z(svbool_t_val, svint8_t_val); + svqneg_z(svbool_t_val, svint16_t_val); + svqneg_z(svbool_t_val, svint32_t_val); + svqneg_z(svbool_t_val, svint64_t_val); + svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmulh(svint8_t_val, int8_t_val); + svqrdmulh(svint8_t_val, svint8_t_val); + svqrdmulh(svint16_t_val, int16_t_val); + svqrdmulh(svint16_t_val, svint16_t_val); + svqrdmulh(svint32_t_val, int32_t_val); + svqrdmulh(svint32_t_val, svint32_t_val); + svqrdmulh(svint64_t_val, int64_t_val); + svqrdmulh(svint64_t_val, svint64_t_val); + svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqrdmulh_n_s8(svint8_t_val, int8_t_val); + svqrdmulh_n_s16(svint16_t_val, int16_t_val); + svqrdmulh_n_s32(svint32_t_val, int32_t_val); + svqrdmulh_n_s64(svint64_t_val, int64_t_val); + svqrdmulh_s8(svint8_t_val, svint8_t_val); + svqrdmulh_s16(svint16_t_val, svint16_t_val); + svqrdmulh_s32(svint32_t_val, svint32_t_val); + svqrdmulh_s64(svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshrnb(svint16_t_val, 2); + svqrshrnb(svint32_t_val, 2); + svqrshrnb(svint64_t_val, 2); + svqrshrnb(svuint16_t_val, 2); + svqrshrnb(svuint32_t_val, 2); + svqrshrnb(svuint64_t_val, 2); + svqrshrnb_n_s16(svint16_t_val, 2); + svqrshrnb_n_s32(svint32_t_val, 2); + svqrshrnb_n_s64(svint64_t_val, 2); + svqrshrnb_n_u16(svuint16_t_val, 2); + svqrshrnb_n_u32(svuint32_t_val, 2); + svqrshrnb_n_u64(svuint64_t_val, 2); + svqrshrnt(svint8_t_val, svint16_t_val, 2); + svqrshrnt(svint16_t_val, svint32_t_val, 2); + svqrshrnt(svint32_t_val, svint64_t_val, 2); + svqrshrnt(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt(svuint32_t_val, svuint64_t_val, 2); + svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqrshrunb(svint16_t_val, 2); + svqrshrunb(svint32_t_val, 2); + svqrshrunb(svint64_t_val, 2); + svqrshrunb_n_s16(svint16_t_val, 2); + svqrshrunb_n_s32(svint32_t_val, 2); + svqrshrunb_n_s64(svint64_t_val, 2); + svqrshrunt(svuint8_t_val, svint16_t_val, 2); + svqrshrunt(svuint16_t_val, svint32_t_val, 2); + svqrshrunt(svuint32_t_val, svint64_t_val, 2); + svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshlu_m(svbool_t_val, svint8_t_val, 2); + svqshlu_m(svbool_t_val, svint16_t_val, 2); + svqshlu_m(svbool_t_val, svint32_t_val, 2); + svqshlu_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); + svqshlu_x(svbool_t_val, svint8_t_val, 2); + svqshlu_x(svbool_t_val, svint16_t_val, 2); + svqshlu_x(svbool_t_val, svint32_t_val, 2); + svqshlu_x(svbool_t_val, svint64_t_val, 2); + svqshlu_z(svbool_t_val, svint8_t_val, 2); + svqshlu_z(svbool_t_val, svint16_t_val, 2); + svqshlu_z(svbool_t_val, svint32_t_val, 2); + svqshlu_z(svbool_t_val, svint64_t_val, 2); + svqshrnb(svint16_t_val, 2); + svqshrnb(svint32_t_val, 2); + svqshrnb(svint64_t_val, 2); + svqshrnb(svuint16_t_val, 2); + svqshrnb(svuint32_t_val, 2); + svqshrnb(svuint64_t_val, 2); + svqshrnb_n_s16(svint16_t_val, 2); + svqshrnb_n_s32(svint32_t_val, 2); + svqshrnb_n_s64(svint64_t_val, 2); + svqshrnb_n_u16(svuint16_t_val, 2); + svqshrnb_n_u32(svuint32_t_val, 2); + svqshrnb_n_u64(svuint64_t_val, 2); + svqshrnt(svint8_t_val, svint16_t_val, 2); + svqshrnt(svint16_t_val, svint32_t_val, 2); + svqshrnt(svint32_t_val, svint64_t_val, 2); + svqshrnt(svuint8_t_val, svuint16_t_val, 2); + svqshrnt(svuint16_t_val, svuint32_t_val, 2); + svqshrnt(svuint32_t_val, svuint64_t_val, 2); + svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqshrunb(svint16_t_val, 2); + svqshrunb(svint32_t_val, 2); + svqshrunb(svint64_t_val, 2); + svqshrunb_n_s16(svint16_t_val, 2); + svqshrunb_n_s32(svint32_t_val, 2); + svqshrunb_n_s64(svint64_t_val, 2); + svqshrunt(svuint8_t_val, svint16_t_val, 2); + svqshrunt(svuint16_t_val, svint32_t_val, 2); + svqshrunt(svuint32_t_val, svint64_t_val, 2); + svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqxtnb(svint16_t_val); + svqxtnb(svint32_t_val); + svqxtnb(svint64_t_val); + svqxtnb(svuint16_t_val); + svqxtnb(svuint32_t_val); + svqxtnb(svuint64_t_val); + svqxtnb_s16(svint16_t_val); + svqxtnb_s32(svint32_t_val); + svqxtnb_s64(svint64_t_val); + svqxtnb_u16(svuint16_t_val); + svqxtnb_u32(svuint32_t_val); + svqxtnb_u64(svuint64_t_val); + svqxtnt(svint8_t_val, svint16_t_val); + svqxtnt(svint16_t_val, svint32_t_val); + svqxtnt(svint32_t_val, svint64_t_val); + svqxtnt(svuint8_t_val, svuint16_t_val); + svqxtnt(svuint16_t_val, svuint32_t_val); + svqxtnt(svuint32_t_val, svuint64_t_val); + svqxtnt_s16(svint8_t_val, svint16_t_val); + svqxtnt_s32(svint16_t_val, svint32_t_val); + svqxtnt_s64(svint32_t_val, svint64_t_val); + svqxtnt_u16(svuint8_t_val, svuint16_t_val); + svqxtnt_u32(svuint16_t_val, svuint32_t_val); + svqxtnt_u64(svuint32_t_val, svuint64_t_val); + svqxtunb(svint16_t_val); + svqxtunb(svint32_t_val); + svqxtunb(svint64_t_val); + svqxtunb_s16(svint16_t_val); + svqxtunb_s32(svint32_t_val); + svqxtunb_s64(svint64_t_val); + svqxtunt(svuint8_t_val, svint16_t_val); + svqxtunt(svuint16_t_val, svint32_t_val); + svqxtunt(svuint32_t_val, svint64_t_val); + svqxtunt_s16(svuint8_t_val, svint16_t_val); + svqxtunt_s32(svuint16_t_val, svint32_t_val); + svqxtunt_s64(svuint32_t_val, svint64_t_val); + svraddhnb(svint16_t_val, int16_t_val); + svraddhnb(svint16_t_val, svint16_t_val); + svraddhnb(svint32_t_val, int32_t_val); + svraddhnb(svint32_t_val, svint32_t_val); + svraddhnb(svint64_t_val, int64_t_val); + svraddhnb(svint64_t_val, svint64_t_val); + svraddhnb(svuint16_t_val, svuint16_t_val); + svraddhnb(svuint16_t_val, uint16_t_val); + svraddhnb(svuint32_t_val, svuint32_t_val); + svraddhnb(svuint32_t_val, uint32_t_val); + svraddhnb(svuint64_t_val, svuint64_t_val); + svraddhnb(svuint64_t_val, uint64_t_val); + svraddhnb_n_s16(svint16_t_val, int16_t_val); + svraddhnb_n_s32(svint32_t_val, int32_t_val); + svraddhnb_n_s64(svint64_t_val, int64_t_val); + svraddhnb_n_u16(svuint16_t_val, uint16_t_val); + svraddhnb_n_u32(svuint32_t_val, uint32_t_val); + svraddhnb_n_u64(svuint64_t_val, uint64_t_val); + svraddhnb_s16(svint16_t_val, svint16_t_val); + svraddhnb_s32(svint32_t_val, svint32_t_val); + svraddhnb_s64(svint64_t_val, svint64_t_val); + svraddhnb_u16(svuint16_t_val, svuint16_t_val); + svraddhnb_u32(svuint32_t_val, svuint32_t_val); + svraddhnb_u64(svuint64_t_val, svuint64_t_val); + svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_x(svbool_t_val, svuint32_t_val); + svrecpe_u32_z(svbool_t_val, svuint32_t_val); + svrecpe_x(svbool_t_val, svuint32_t_val); + svrecpe_z(svbool_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshr_m(svbool_t_val, svint8_t_val, 2); + svrshr_m(svbool_t_val, svint16_t_val, 2); + svrshr_m(svbool_t_val, svint32_t_val, 2); + svrshr_m(svbool_t_val, svint64_t_val, 2); + svrshr_m(svbool_t_val, svuint8_t_val, 2); + svrshr_m(svbool_t_val, svuint16_t_val, 2); + svrshr_m(svbool_t_val, svuint32_t_val, 2); + svrshr_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); + svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); + svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); + svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); + svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); + svrshr_x(svbool_t_val, svint8_t_val, 2); + svrshr_x(svbool_t_val, svint16_t_val, 2); + svrshr_x(svbool_t_val, svint32_t_val, 2); + svrshr_x(svbool_t_val, svint64_t_val, 2); + svrshr_x(svbool_t_val, svuint8_t_val, 2); + svrshr_x(svbool_t_val, svuint16_t_val, 2); + svrshr_x(svbool_t_val, svuint32_t_val, 2); + svrshr_x(svbool_t_val, svuint64_t_val, 2); + svrshr_z(svbool_t_val, svint8_t_val, 2); + svrshr_z(svbool_t_val, svint16_t_val, 2); + svrshr_z(svbool_t_val, svint32_t_val, 2); + svrshr_z(svbool_t_val, svint64_t_val, 2); + svrshr_z(svbool_t_val, svuint8_t_val, 2); + svrshr_z(svbool_t_val, svuint16_t_val, 2); + svrshr_z(svbool_t_val, svuint32_t_val, 2); + svrshr_z(svbool_t_val, svuint64_t_val, 2); + svrshrnb(svint16_t_val, 2); + svrshrnb(svint32_t_val, 2); + svrshrnb(svint64_t_val, 2); + svrshrnb(svuint16_t_val, 2); + svrshrnb(svuint32_t_val, 2); + svrshrnb(svuint64_t_val, 2); + svrshrnb_n_s16(svint16_t_val, 2); + svrshrnb_n_s32(svint32_t_val, 2); + svrshrnb_n_s64(svint64_t_val, 2); + svrshrnb_n_u16(svuint16_t_val, 2); + svrshrnb_n_u32(svuint32_t_val, 2); + svrshrnb_n_u64(svuint64_t_val, 2); + svrshrnt(svint8_t_val, svint16_t_val, 2); + svrshrnt(svint16_t_val, svint32_t_val, 2); + svrshrnt(svint32_t_val, svint64_t_val, 2); + svrshrnt(svuint8_t_val, svuint16_t_val, 2); + svrshrnt(svuint16_t_val, svuint32_t_val, 2); + svrshrnt(svuint32_t_val, svuint64_t_val, 2); + svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_x(svbool_t_val, svuint32_t_val); + svrsqrte_u32_z(svbool_t_val, svuint32_t_val); + svrsqrte_x(svbool_t_val, svuint32_t_val); + svrsqrte_z(svbool_t_val, svuint32_t_val); + svrsra(svint8_t_val, svint8_t_val, 2); + svrsra(svint16_t_val, svint16_t_val, 2); + svrsra(svint32_t_val, svint32_t_val, 2); + svrsra(svint64_t_val, svint64_t_val, 2); + svrsra(svuint8_t_val, svuint8_t_val, 2); + svrsra(svuint16_t_val, svuint16_t_val, 2); + svrsra(svuint32_t_val, svuint32_t_val, 2); + svrsra(svuint64_t_val, svuint64_t_val, 2); + svrsra_n_s8(svint8_t_val, svint8_t_val, 2); + svrsra_n_s16(svint16_t_val, svint16_t_val, 2); + svrsra_n_s32(svint32_t_val, svint32_t_val, 2); + svrsra_n_s64(svint64_t_val, svint64_t_val, 2); + svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svrsubhnb(svint16_t_val, int16_t_val); + svrsubhnb(svint16_t_val, svint16_t_val); + svrsubhnb(svint32_t_val, int32_t_val); + svrsubhnb(svint32_t_val, svint32_t_val); + svrsubhnb(svint64_t_val, int64_t_val); + svrsubhnb(svint64_t_val, svint64_t_val); + svrsubhnb(svuint16_t_val, svuint16_t_val); + svrsubhnb(svuint16_t_val, uint16_t_val); + svrsubhnb(svuint32_t_val, svuint32_t_val); + svrsubhnb(svuint32_t_val, uint32_t_val); + svrsubhnb(svuint64_t_val, svuint64_t_val); + svrsubhnb(svuint64_t_val, uint64_t_val); + svrsubhnb_n_s16(svint16_t_val, int16_t_val); + svrsubhnb_n_s32(svint32_t_val, int32_t_val); + svrsubhnb_n_s64(svint64_t_val, int64_t_val); + svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svrsubhnb_s16(svint16_t_val, svint16_t_val); + svrsubhnb_s32(svint32_t_val, svint32_t_val); + svrsubhnb_s64(svint64_t_val, svint64_t_val); + svrsubhnb_u16(svuint16_t_val, svuint16_t_val); + svrsubhnb_u32(svuint32_t_val, svuint32_t_val); + svrsubhnb_u64(svuint64_t_val, svuint64_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svshllb(svint8_t_val, 2); + svshllb(svint16_t_val, 2); + svshllb(svint32_t_val, 2); + svshllb(svuint8_t_val, 2); + svshllb(svuint16_t_val, 2); + svshllb(svuint32_t_val, 2); + svshllb_n_s16(svint8_t_val, 2); + svshllb_n_s32(svint16_t_val, 2); + svshllb_n_s64(svint32_t_val, 2); + svshllb_n_u16(svuint8_t_val, 2); + svshllb_n_u32(svuint16_t_val, 2); + svshllb_n_u64(svuint32_t_val, 2); + svshllt(svint8_t_val, 2); + svshllt(svint16_t_val, 2); + svshllt(svint32_t_val, 2); + svshllt(svuint8_t_val, 2); + svshllt(svuint16_t_val, 2); + svshllt(svuint32_t_val, 2); + svshllt_n_s16(svint8_t_val, 2); + svshllt_n_s32(svint16_t_val, 2); + svshllt_n_s64(svint32_t_val, 2); + svshllt_n_u16(svuint8_t_val, 2); + svshllt_n_u32(svuint16_t_val, 2); + svshllt_n_u64(svuint32_t_val, 2); + svshrnb(svint16_t_val, 2); + svshrnb(svint32_t_val, 2); + svshrnb(svint64_t_val, 2); + svshrnb(svuint16_t_val, 2); + svshrnb(svuint32_t_val, 2); + svshrnb(svuint64_t_val, 2); + svshrnb_n_s16(svint16_t_val, 2); + svshrnb_n_s32(svint32_t_val, 2); + svshrnb_n_s64(svint64_t_val, 2); + svshrnb_n_u16(svuint16_t_val, 2); + svshrnb_n_u32(svuint32_t_val, 2); + svshrnb_n_u64(svuint64_t_val, 2); + svshrnt(svint8_t_val, svint16_t_val, 2); + svshrnt(svint16_t_val, svint32_t_val, 2); + svshrnt(svint32_t_val, svint64_t_val, 2); + svshrnt(svuint8_t_val, svuint16_t_val, 2); + svshrnt(svuint16_t_val, svuint32_t_val, 2); + svshrnt(svuint32_t_val, svuint64_t_val, 2); + svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svsli(svint8_t_val, svint8_t_val, 2); + svsli(svint16_t_val, svint16_t_val, 2); + svsli(svint32_t_val, svint32_t_val, 2); + svsli(svint64_t_val, svint64_t_val, 2); + svsli(svuint8_t_val, svuint8_t_val, 2); + svsli(svuint16_t_val, svuint16_t_val, 2); + svsli(svuint32_t_val, svuint32_t_val, 2); + svsli(svuint64_t_val, svuint64_t_val, 2); + svsli_n_s8(svint8_t_val, svint8_t_val, 2); + svsli_n_s16(svint16_t_val, svint16_t_val, 2); + svsli_n_s32(svint32_t_val, svint32_t_val, 2); + svsli_n_s64(svint64_t_val, svint64_t_val, 2); + svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsra(svint8_t_val, svint8_t_val, 2); + svsra(svint16_t_val, svint16_t_val, 2); + svsra(svint32_t_val, svint32_t_val, 2); + svsra(svint64_t_val, svint64_t_val, 2); + svsra(svuint8_t_val, svuint8_t_val, 2); + svsra(svuint16_t_val, svuint16_t_val, 2); + svsra(svuint32_t_val, svuint32_t_val, 2); + svsra(svuint64_t_val, svuint64_t_val, 2); + svsra_n_s8(svint8_t_val, svint8_t_val, 2); + svsra_n_s16(svint16_t_val, svint16_t_val, 2); + svsra_n_s32(svint32_t_val, svint32_t_val, 2); + svsra_n_s64(svint64_t_val, svint64_t_val, 2); + svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsri(svint8_t_val, svint8_t_val, 2); + svsri(svint16_t_val, svint16_t_val, 2); + svsri(svint32_t_val, svint32_t_val, 2); + svsri(svint64_t_val, svint64_t_val, 2); + svsri(svuint8_t_val, svuint8_t_val, 2); + svsri(svuint16_t_val, svuint16_t_val, 2); + svsri(svuint32_t_val, svuint32_t_val, 2); + svsri(svuint64_t_val, svuint64_t_val, 2); + svsri_n_s8(svint8_t_val, svint8_t_val, 2); + svsri_n_s16(svint16_t_val, svint16_t_val, 2); + svsri_n_s32(svint32_t_val, svint32_t_val, 2); + svsri_n_s64(svint64_t_val, svint64_t_val, 2); + svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsubhnb(svint16_t_val, int16_t_val); + svsubhnb(svint16_t_val, svint16_t_val); + svsubhnb(svint32_t_val, int32_t_val); + svsubhnb(svint32_t_val, svint32_t_val); + svsubhnb(svint64_t_val, int64_t_val); + svsubhnb(svint64_t_val, svint64_t_val); + svsubhnb(svuint16_t_val, svuint16_t_val); + svsubhnb(svuint16_t_val, uint16_t_val); + svsubhnb(svuint32_t_val, svuint32_t_val); + svsubhnb(svuint32_t_val, uint32_t_val); + svsubhnb(svuint64_t_val, svuint64_t_val); + svsubhnb(svuint64_t_val, uint64_t_val); + svsubhnb_n_s16(svint16_t_val, int16_t_val); + svsubhnb_n_s32(svint32_t_val, int32_t_val); + svsubhnb_n_s64(svint64_t_val, int64_t_val); + svsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svsubhnb_s16(svint16_t_val, svint16_t_val); + svsubhnb_s32(svint32_t_val, svint32_t_val); + svsubhnb_s64(svint64_t_val, svint64_t_val); + svsubhnb_u16(svuint16_t_val, svuint16_t_val); + svsubhnb_u32(svuint32_t_val, svuint32_t_val); + svsubhnb_u64(svuint64_t_val, svuint64_t_val); + svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsublb(svint8_t_val, int8_t_val); + svsublb(svint8_t_val, svint8_t_val); + svsublb(svint16_t_val, int16_t_val); + svsublb(svint16_t_val, svint16_t_val); + svsublb(svint32_t_val, int32_t_val); + svsublb(svint32_t_val, svint32_t_val); + svsublb(svuint8_t_val, svuint8_t_val); + svsublb(svuint8_t_val, uint8_t_val); + svsublb(svuint16_t_val, svuint16_t_val); + svsublb(svuint16_t_val, uint16_t_val); + svsublb(svuint32_t_val, svuint32_t_val); + svsublb(svuint32_t_val, uint32_t_val); + svsublb_n_s16(svint8_t_val, int8_t_val); + svsublb_n_s32(svint16_t_val, int16_t_val); + svsublb_n_s64(svint32_t_val, int32_t_val); + svsublb_n_u16(svuint8_t_val, uint8_t_val); + svsublb_n_u32(svuint16_t_val, uint16_t_val); + svsublb_n_u64(svuint32_t_val, uint32_t_val); + svsublb_s16(svint8_t_val, svint8_t_val); + svsublb_s32(svint16_t_val, svint16_t_val); + svsublb_s64(svint32_t_val, svint32_t_val); + svsublb_u16(svuint8_t_val, svuint8_t_val); + svsublb_u32(svuint16_t_val, svuint16_t_val); + svsublb_u64(svuint32_t_val, svuint32_t_val); + svsublbt(svint8_t_val, int8_t_val); + svsublbt(svint8_t_val, svint8_t_val); + svsublbt(svint16_t_val, int16_t_val); + svsublbt(svint16_t_val, svint16_t_val); + svsublbt(svint32_t_val, int32_t_val); + svsublbt(svint32_t_val, svint32_t_val); + svsublbt_n_s16(svint8_t_val, int8_t_val); + svsublbt_n_s32(svint16_t_val, int16_t_val); + svsublbt_n_s64(svint32_t_val, int32_t_val); + svsublbt_s16(svint8_t_val, svint8_t_val); + svsublbt_s32(svint16_t_val, svint16_t_val); + svsublbt_s64(svint32_t_val, svint32_t_val); + svsublt(svint8_t_val, int8_t_val); + svsublt(svint8_t_val, svint8_t_val); + svsublt(svint16_t_val, int16_t_val); + svsublt(svint16_t_val, svint16_t_val); + svsublt(svint32_t_val, int32_t_val); + svsublt(svint32_t_val, svint32_t_val); + svsublt(svuint8_t_val, svuint8_t_val); + svsublt(svuint8_t_val, uint8_t_val); + svsublt(svuint16_t_val, svuint16_t_val); + svsublt(svuint16_t_val, uint16_t_val); + svsublt(svuint32_t_val, svuint32_t_val); + svsublt(svuint32_t_val, uint32_t_val); + svsublt_n_s16(svint8_t_val, int8_t_val); + svsublt_n_s32(svint16_t_val, int16_t_val); + svsublt_n_s64(svint32_t_val, int32_t_val); + svsublt_n_u16(svuint8_t_val, uint8_t_val); + svsublt_n_u32(svuint16_t_val, uint16_t_val); + svsublt_n_u64(svuint32_t_val, uint32_t_val); + svsublt_s16(svint8_t_val, svint8_t_val); + svsublt_s32(svint16_t_val, svint16_t_val); + svsublt_s64(svint32_t_val, svint32_t_val); + svsublt_u16(svuint8_t_val, svuint8_t_val); + svsublt_u32(svuint16_t_val, svuint16_t_val); + svsublt_u64(svuint32_t_val, svuint32_t_val); + svsubltb(svint8_t_val, int8_t_val); + svsubltb(svint8_t_val, svint8_t_val); + svsubltb(svint16_t_val, int16_t_val); + svsubltb(svint16_t_val, svint16_t_val); + svsubltb(svint32_t_val, int32_t_val); + svsubltb(svint32_t_val, svint32_t_val); + svsubltb_n_s16(svint8_t_val, int8_t_val); + svsubltb_n_s32(svint16_t_val, int16_t_val); + svsubltb_n_s64(svint32_t_val, int32_t_val); + svsubltb_s16(svint8_t_val, svint8_t_val); + svsubltb_s32(svint16_t_val, svint16_t_val); + svsubltb_s64(svint32_t_val, svint32_t_val); + svsubwb(svint16_t_val, int8_t_val); + svsubwb(svint16_t_val, svint8_t_val); + svsubwb(svint32_t_val, int16_t_val); + svsubwb(svint32_t_val, svint16_t_val); + svsubwb(svint64_t_val, int32_t_val); + svsubwb(svint64_t_val, svint32_t_val); + svsubwb(svuint16_t_val, svuint8_t_val); + svsubwb(svuint16_t_val, uint8_t_val); + svsubwb(svuint32_t_val, svuint16_t_val); + svsubwb(svuint32_t_val, uint16_t_val); + svsubwb(svuint64_t_val, svuint32_t_val); + svsubwb(svuint64_t_val, uint32_t_val); + svsubwb_n_s16(svint16_t_val, int8_t_val); + svsubwb_n_s32(svint32_t_val, int16_t_val); + svsubwb_n_s64(svint64_t_val, int32_t_val); + svsubwb_n_u16(svuint16_t_val, uint8_t_val); + svsubwb_n_u32(svuint32_t_val, uint16_t_val); + svsubwb_n_u64(svuint64_t_val, uint32_t_val); + svsubwb_s16(svint16_t_val, svint8_t_val); + svsubwb_s32(svint32_t_val, svint16_t_val); + svsubwb_s64(svint64_t_val, svint32_t_val); + svsubwb_u16(svuint16_t_val, svuint8_t_val); + svsubwb_u32(svuint32_t_val, svuint16_t_val); + svsubwb_u64(svuint64_t_val, svuint32_t_val); + svsubwt(svint16_t_val, int8_t_val); + svsubwt(svint16_t_val, svint8_t_val); + svsubwt(svint32_t_val, int16_t_val); + svsubwt(svint32_t_val, svint16_t_val); + svsubwt(svint64_t_val, int32_t_val); + svsubwt(svint64_t_val, svint32_t_val); + svsubwt(svuint16_t_val, svuint8_t_val); + svsubwt(svuint16_t_val, uint8_t_val); + svsubwt(svuint32_t_val, svuint16_t_val); + svsubwt(svuint32_t_val, uint16_t_val); + svsubwt(svuint64_t_val, svuint32_t_val); + svsubwt(svuint64_t_val, uint32_t_val); + svsubwt_n_s16(svint16_t_val, int8_t_val); + svsubwt_n_s32(svint32_t_val, int16_t_val); + svsubwt_n_s64(svint64_t_val, int32_t_val); + svsubwt_n_u16(svuint16_t_val, uint8_t_val); + svsubwt_n_u32(svuint32_t_val, uint16_t_val); + svsubwt_n_u64(svuint64_t_val, uint32_t_val); + svsubwt_s16(svint16_t_val, svint8_t_val); + svsubwt_s32(svint32_t_val, svint16_t_val); + svsubwt_s64(svint64_t_val, svint32_t_val); + svsubwt_u16(svuint16_t_val, svuint8_t_val); + svsubwt_u32(svuint32_t_val, svuint16_t_val); + svsubwt_u64(svuint64_t_val, svuint32_t_val); + svtbl2(svbfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat32x2_t_val, svuint32_t_val); + svtbl2(svfloat64x2_t_val, svuint64_t_val); + svtbl2(svint8x2_t_val, svuint8_t_val); + svtbl2(svint16x2_t_val, svuint16_t_val); + svtbl2(svint32x2_t_val, svuint32_t_val); + svtbl2(svint64x2_t_val, svuint64_t_val); + svtbl2(svuint8x2_t_val, svuint8_t_val); + svtbl2(svuint16x2_t_val, svuint16_t_val); + svtbl2(svuint32x2_t_val, svuint32_t_val); + svtbl2(svuint64x2_t_val, svuint64_t_val); + svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); + svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); + svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); + svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); + svtbl2_s8(svint8x2_t_val, svuint8_t_val); + svtbl2_s16(svint16x2_t_val, svuint16_t_val); + svtbl2_s32(svint32x2_t_val, svuint32_t_val); + svtbl2_s64(svint64x2_t_val, svuint64_t_val); + svtbl2_u8(svuint8x2_t_val, svuint8_t_val); + svtbl2_u16(svuint16x2_t_val, svuint16_t_val); + svtbl2_u32(svuint32x2_t_val, svuint32_t_val); + svtbl2_u64(svuint64x2_t_val, svuint64_t_val); + svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); + svwhilege_b8(int32_t_val, int32_t_val); + svwhilege_b8(int64_t_val, int64_t_val); + svwhilege_b8(uint32_t_val, uint32_t_val); + svwhilege_b8(uint64_t_val, uint64_t_val); + svwhilege_b8_s32(int32_t_val, int32_t_val); + svwhilege_b8_s64(int64_t_val, int64_t_val); + svwhilege_b8_u32(uint32_t_val, uint32_t_val); + svwhilege_b8_u64(uint64_t_val, uint64_t_val); + svwhilege_b16(int32_t_val, int32_t_val); + svwhilege_b16(int64_t_val, int64_t_val); + svwhilege_b16(uint32_t_val, uint32_t_val); + svwhilege_b16(uint64_t_val, uint64_t_val); + svwhilege_b16_s32(int32_t_val, int32_t_val); + svwhilege_b16_s64(int64_t_val, int64_t_val); + svwhilege_b16_u32(uint32_t_val, uint32_t_val); + svwhilege_b16_u64(uint64_t_val, uint64_t_val); + svwhilege_b32(int32_t_val, int32_t_val); + svwhilege_b32(int64_t_val, int64_t_val); + svwhilege_b32(uint32_t_val, uint32_t_val); + svwhilege_b32(uint64_t_val, uint64_t_val); + svwhilege_b32_s32(int32_t_val, int32_t_val); + svwhilege_b32_s64(int64_t_val, int64_t_val); + svwhilege_b32_u32(uint32_t_val, uint32_t_val); + svwhilege_b32_u64(uint64_t_val, uint64_t_val); + svwhilege_b64(int32_t_val, int32_t_val); + svwhilege_b64(int64_t_val, int64_t_val); + svwhilege_b64(uint32_t_val, uint32_t_val); + svwhilege_b64(uint64_t_val, uint64_t_val); + svwhilege_b64_s32(int32_t_val, int32_t_val); + svwhilege_b64_s64(int64_t_val, int64_t_val); + svwhilege_b64_u32(uint32_t_val, uint32_t_val); + svwhilege_b64_u64(uint64_t_val, uint64_t_val); + svwhilegt_b8(int32_t_val, int32_t_val); + svwhilegt_b8(int64_t_val, int64_t_val); + svwhilegt_b8(uint32_t_val, uint32_t_val); + svwhilegt_b8(uint64_t_val, uint64_t_val); + svwhilegt_b8_s32(int32_t_val, int32_t_val); + svwhilegt_b8_s64(int64_t_val, int64_t_val); + svwhilegt_b8_u32(uint32_t_val, uint32_t_val); + svwhilegt_b8_u64(uint64_t_val, uint64_t_val); + svwhilegt_b16(int32_t_val, int32_t_val); + svwhilegt_b16(int64_t_val, int64_t_val); + svwhilegt_b16(uint32_t_val, uint32_t_val); + svwhilegt_b16(uint64_t_val, uint64_t_val); + svwhilegt_b16_s32(int32_t_val, int32_t_val); + svwhilegt_b16_s64(int64_t_val, int64_t_val); + svwhilegt_b16_u32(uint32_t_val, uint32_t_val); + svwhilegt_b16_u64(uint64_t_val, uint64_t_val); + svwhilegt_b32(int32_t_val, int32_t_val); + svwhilegt_b32(int64_t_val, int64_t_val); + svwhilegt_b32(uint32_t_val, uint32_t_val); + svwhilegt_b32(uint64_t_val, uint64_t_val); + svwhilegt_b32_s32(int32_t_val, int32_t_val); + svwhilegt_b32_s64(int64_t_val, int64_t_val); + svwhilegt_b32_u32(uint32_t_val, uint32_t_val); + svwhilegt_b32_u64(uint64_t_val, uint64_t_val); + svwhilegt_b64(int32_t_val, int32_t_val); + svwhilegt_b64(int64_t_val, int64_t_val); + svwhilegt_b64(uint32_t_val, uint32_t_val); + svwhilegt_b64(uint64_t_val, uint64_t_val); + svwhilegt_b64_s32(int32_t_val, int32_t_val); + svwhilegt_b64_s64(int64_t_val, int64_t_val); + svwhilegt_b64_u32(uint32_t_val, uint32_t_val); + svwhilegt_b64_u64(uint64_t_val, uint64_t_val); + svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svxar(svint8_t_val, svint8_t_val, 2); + svxar(svint16_t_val, svint16_t_val, 2); + svxar(svint32_t_val, svint32_t_val, 2); + svxar(svint64_t_val, svint64_t_val, 2); + svxar(svuint8_t_val, svuint8_t_val, 2); + svxar(svuint16_t_val, svuint16_t_val, 2); + svxar(svuint32_t_val, svuint32_t_val, 2); + svxar(svuint64_t_val, svuint64_t_val, 2); + svxar_n_s8(svint8_t_val, svint8_t_val, 2); + svxar_n_s16(svint16_t_val, svint16_t_val, 2); + svxar_n_s32(svint32_t_val, svint32_t_val, 2); + svxar_n_s64(svint64_t_val, svint64_t_val, 2); + svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); + svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); + svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); + svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + svaba(svint8_t_val, svint8_t_val, int8_t_val); + svaba(svint8_t_val, svint8_t_val, svint8_t_val); + svaba(svint16_t_val, svint16_t_val, int16_t_val); + svaba(svint16_t_val, svint16_t_val, svint16_t_val); + svaba(svint32_t_val, svint32_t_val, int32_t_val); + svaba(svint32_t_val, svint32_t_val, svint32_t_val); + svaba(svint64_t_val, svint64_t_val, int64_t_val); + svaba(svint64_t_val, svint64_t_val, svint64_t_val); + svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svabalb(svint16_t_val, svint8_t_val, int8_t_val); + svabalb(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb(svint32_t_val, svint16_t_val, int16_t_val); + svabalb(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb(svint64_t_val, svint32_t_val, int32_t_val); + svabalb(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svint16_t_val, svint8_t_val, int8_t_val); + svabalt(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt(svint32_t_val, svint16_t_val, int16_t_val); + svabalt(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt(svint64_t_val, svint32_t_val, int32_t_val); + svabalt(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabdlb(svint8_t_val, int8_t_val); + svabdlb(svint8_t_val, svint8_t_val); + svabdlb(svint16_t_val, int16_t_val); + svabdlb(svint16_t_val, svint16_t_val); + svabdlb(svint32_t_val, int32_t_val); + svabdlb(svint32_t_val, svint32_t_val); + svabdlb(svuint8_t_val, svuint8_t_val); + svabdlb(svuint8_t_val, uint8_t_val); + svabdlb(svuint16_t_val, svuint16_t_val); + svabdlb(svuint16_t_val, uint16_t_val); + svabdlb(svuint32_t_val, svuint32_t_val); + svabdlb(svuint32_t_val, uint32_t_val); + svabdlb_n_s16(svint8_t_val, int8_t_val); + svabdlb_n_s32(svint16_t_val, int16_t_val); + svabdlb_n_s64(svint32_t_val, int32_t_val); + svabdlb_n_u16(svuint8_t_val, uint8_t_val); + svabdlb_n_u32(svuint16_t_val, uint16_t_val); + svabdlb_n_u64(svuint32_t_val, uint32_t_val); + svabdlb_s16(svint8_t_val, svint8_t_val); + svabdlb_s32(svint16_t_val, svint16_t_val); + svabdlb_s64(svint32_t_val, svint32_t_val); + svabdlb_u16(svuint8_t_val, svuint8_t_val); + svabdlb_u32(svuint16_t_val, svuint16_t_val); + svabdlb_u64(svuint32_t_val, svuint32_t_val); + svabdlt(svint8_t_val, int8_t_val); + svabdlt(svint8_t_val, svint8_t_val); + svabdlt(svint16_t_val, int16_t_val); + svabdlt(svint16_t_val, svint16_t_val); + svabdlt(svint32_t_val, int32_t_val); + svabdlt(svint32_t_val, svint32_t_val); + svabdlt(svuint8_t_val, svuint8_t_val); + svabdlt(svuint8_t_val, uint8_t_val); + svabdlt(svuint16_t_val, svuint16_t_val); + svabdlt(svuint16_t_val, uint16_t_val); + svabdlt(svuint32_t_val, svuint32_t_val); + svabdlt(svuint32_t_val, uint32_t_val); + svabdlt_n_s16(svint8_t_val, int8_t_val); + svabdlt_n_s32(svint16_t_val, int16_t_val); + svabdlt_n_s64(svint32_t_val, int32_t_val); + svabdlt_n_u16(svuint8_t_val, uint8_t_val); + svabdlt_n_u32(svuint16_t_val, uint16_t_val); + svabdlt_n_u64(svuint32_t_val, uint32_t_val); + svabdlt_s16(svint8_t_val, svint8_t_val); + svabdlt_s32(svint16_t_val, svint16_t_val); + svabdlt_s64(svint32_t_val, svint32_t_val); + svabdlt_u16(svuint8_t_val, svuint8_t_val); + svabdlt_u32(svuint16_t_val, svuint16_t_val); + svabdlt_u64(svuint32_t_val, svuint32_t_val); + svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaddhnb(svint16_t_val, int16_t_val); + svaddhnb(svint16_t_val, svint16_t_val); + svaddhnb(svint32_t_val, int32_t_val); + svaddhnb(svint32_t_val, svint32_t_val); + svaddhnb(svint64_t_val, int64_t_val); + svaddhnb(svint64_t_val, svint64_t_val); + svaddhnb(svuint16_t_val, svuint16_t_val); + svaddhnb(svuint16_t_val, uint16_t_val); + svaddhnb(svuint32_t_val, svuint32_t_val); + svaddhnb(svuint32_t_val, uint32_t_val); + svaddhnb(svuint64_t_val, svuint64_t_val); + svaddhnb(svuint64_t_val, uint64_t_val); + svaddhnb_n_s16(svint16_t_val, int16_t_val); + svaddhnb_n_s32(svint32_t_val, int32_t_val); + svaddhnb_n_s64(svint64_t_val, int64_t_val); + svaddhnb_n_u16(svuint16_t_val, uint16_t_val); + svaddhnb_n_u32(svuint32_t_val, uint32_t_val); + svaddhnb_n_u64(svuint64_t_val, uint64_t_val); + svaddhnb_s16(svint16_t_val, svint16_t_val); + svaddhnb_s32(svint32_t_val, svint32_t_val); + svaddhnb_s64(svint64_t_val, svint64_t_val); + svaddhnb_u16(svuint16_t_val, svuint16_t_val); + svaddhnb_u32(svuint32_t_val, svuint32_t_val); + svaddhnb_u64(svuint64_t_val, svuint64_t_val); + svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddlb(svint8_t_val, int8_t_val); + svaddlb(svint8_t_val, svint8_t_val); + svaddlb(svint16_t_val, int16_t_val); + svaddlb(svint16_t_val, svint16_t_val); + svaddlb(svint32_t_val, int32_t_val); + svaddlb(svint32_t_val, svint32_t_val); + svaddlb(svuint8_t_val, svuint8_t_val); + svaddlb(svuint8_t_val, uint8_t_val); + svaddlb(svuint16_t_val, svuint16_t_val); + svaddlb(svuint16_t_val, uint16_t_val); + svaddlb(svuint32_t_val, svuint32_t_val); + svaddlb(svuint32_t_val, uint32_t_val); + svaddlb_n_s16(svint8_t_val, int8_t_val); + svaddlb_n_s32(svint16_t_val, int16_t_val); + svaddlb_n_s64(svint32_t_val, int32_t_val); + svaddlb_n_u16(svuint8_t_val, uint8_t_val); + svaddlb_n_u32(svuint16_t_val, uint16_t_val); + svaddlb_n_u64(svuint32_t_val, uint32_t_val); + svaddlb_s16(svint8_t_val, svint8_t_val); + svaddlb_s32(svint16_t_val, svint16_t_val); + svaddlb_s64(svint32_t_val, svint32_t_val); + svaddlb_u16(svuint8_t_val, svuint8_t_val); + svaddlb_u32(svuint16_t_val, svuint16_t_val); + svaddlb_u64(svuint32_t_val, svuint32_t_val); + svaddlbt(svint8_t_val, int8_t_val); + svaddlbt(svint8_t_val, svint8_t_val); + svaddlbt(svint16_t_val, int16_t_val); + svaddlbt(svint16_t_val, svint16_t_val); + svaddlbt(svint32_t_val, int32_t_val); + svaddlbt(svint32_t_val, svint32_t_val); + svaddlbt_n_s16(svint8_t_val, int8_t_val); + svaddlbt_n_s32(svint16_t_val, int16_t_val); + svaddlbt_n_s64(svint32_t_val, int32_t_val); + svaddlbt_s16(svint8_t_val, svint8_t_val); + svaddlbt_s32(svint16_t_val, svint16_t_val); + svaddlbt_s64(svint32_t_val, svint32_t_val); + svaddlt(svint8_t_val, int8_t_val); + svaddlt(svint8_t_val, svint8_t_val); + svaddlt(svint16_t_val, int16_t_val); + svaddlt(svint16_t_val, svint16_t_val); + svaddlt(svint32_t_val, int32_t_val); + svaddlt(svint32_t_val, svint32_t_val); + svaddlt(svuint8_t_val, svuint8_t_val); + svaddlt(svuint8_t_val, uint8_t_val); + svaddlt(svuint16_t_val, svuint16_t_val); + svaddlt(svuint16_t_val, uint16_t_val); + svaddlt(svuint32_t_val, svuint32_t_val); + svaddlt(svuint32_t_val, uint32_t_val); + svaddlt_n_s16(svint8_t_val, int8_t_val); + svaddlt_n_s32(svint16_t_val, int16_t_val); + svaddlt_n_s64(svint32_t_val, int32_t_val); + svaddlt_n_u16(svuint8_t_val, uint8_t_val); + svaddlt_n_u32(svuint16_t_val, uint16_t_val); + svaddlt_n_u64(svuint32_t_val, uint32_t_val); + svaddlt_s16(svint8_t_val, svint8_t_val); + svaddlt_s32(svint16_t_val, svint16_t_val); + svaddlt_s64(svint32_t_val, svint32_t_val); + svaddlt_u16(svuint8_t_val, svuint8_t_val); + svaddlt_u32(svuint16_t_val, svuint16_t_val); + svaddlt_u64(svuint32_t_val, svuint32_t_val); + svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddwb(svint16_t_val, int8_t_val); + svaddwb(svint16_t_val, svint8_t_val); + svaddwb(svint32_t_val, int16_t_val); + svaddwb(svint32_t_val, svint16_t_val); + svaddwb(svint64_t_val, int32_t_val); + svaddwb(svint64_t_val, svint32_t_val); + svaddwb(svuint16_t_val, svuint8_t_val); + svaddwb(svuint16_t_val, uint8_t_val); + svaddwb(svuint32_t_val, svuint16_t_val); + svaddwb(svuint32_t_val, uint16_t_val); + svaddwb(svuint64_t_val, svuint32_t_val); + svaddwb(svuint64_t_val, uint32_t_val); + svaddwb_n_s16(svint16_t_val, int8_t_val); + svaddwb_n_s32(svint32_t_val, int16_t_val); + svaddwb_n_s64(svint64_t_val, int32_t_val); + svaddwb_n_u16(svuint16_t_val, uint8_t_val); + svaddwb_n_u32(svuint32_t_val, uint16_t_val); + svaddwb_n_u64(svuint64_t_val, uint32_t_val); + svaddwb_s16(svint16_t_val, svint8_t_val); + svaddwb_s32(svint32_t_val, svint16_t_val); + svaddwb_s64(svint64_t_val, svint32_t_val); + svaddwb_u16(svuint16_t_val, svuint8_t_val); + svaddwb_u32(svuint32_t_val, svuint16_t_val); + svaddwb_u64(svuint64_t_val, svuint32_t_val); + svaddwt(svint16_t_val, int8_t_val); + svaddwt(svint16_t_val, svint8_t_val); + svaddwt(svint32_t_val, int16_t_val); + svaddwt(svint32_t_val, svint16_t_val); + svaddwt(svint64_t_val, int32_t_val); + svaddwt(svint64_t_val, svint32_t_val); + svaddwt(svuint16_t_val, svuint8_t_val); + svaddwt(svuint16_t_val, uint8_t_val); + svaddwt(svuint32_t_val, svuint16_t_val); + svaddwt(svuint32_t_val, uint16_t_val); + svaddwt(svuint64_t_val, svuint32_t_val); + svaddwt(svuint64_t_val, uint32_t_val); + svaddwt_n_s16(svint16_t_val, int8_t_val); + svaddwt_n_s32(svint32_t_val, int16_t_val); + svaddwt_n_s64(svint64_t_val, int32_t_val); + svaddwt_n_u16(svuint16_t_val, uint8_t_val); + svaddwt_n_u32(svuint32_t_val, uint16_t_val); + svaddwt_n_u64(svuint64_t_val, uint32_t_val); + svaddwt_s16(svint16_t_val, svint8_t_val); + svaddwt_s32(svint32_t_val, svint16_t_val); + svaddwt_s64(svint64_t_val, svint32_t_val); + svaddwt_u16(svuint16_t_val, svuint8_t_val); + svaddwt_u32(svuint32_t_val, svuint16_t_val); + svaddwt_u64(svuint64_t_val, svuint32_t_val); + svbcax(svint8_t_val, svint8_t_val, int8_t_val); + svbcax(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax(svint16_t_val, svint16_t_val, int16_t_val); + svbcax(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax(svint32_t_val, svint32_t_val, int32_t_val); + svbcax(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax(svint64_t_val, svint64_t_val, int64_t_val); + svbcax(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svint8_t_val, svint8_t_val, int8_t_val); + svbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl(svint16_t_val, svint16_t_val, int16_t_val); + svbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl(svint32_t_val, svint32_t_val, int32_t_val); + svbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl(svint64_t_val, svint64_t_val, int64_t_val); + svbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcadd(svint8_t_val, svint8_t_val, 90); + svcadd(svint16_t_val, svint16_t_val, 90); + svcadd(svint32_t_val, svint32_t_val, 90); + svcadd(svint64_t_val, svint64_t_val, 90); + svcadd(svuint8_t_val, svuint8_t_val, 90); + svcadd(svuint16_t_val, svuint16_t_val, 90); + svcadd(svuint32_t_val, svuint32_t_val, 90); + svcadd(svuint64_t_val, svuint64_t_val, 90); + svcadd_s8(svint8_t_val, svint8_t_val, 90); + svcadd_s16(svint16_t_val, svint16_t_val, 90); + svcadd_s32(svint32_t_val, svint32_t_val, 90); + svcadd_s64(svint64_t_val, svint64_t_val, 90); + svcadd_u8(svuint8_t_val, svuint8_t_val, 90); + svcadd_u16(svuint16_t_val, svuint16_t_val, 90); + svcadd_u32(svuint32_t_val, svuint32_t_val, 90); + svcadd_u64(svuint64_t_val, svuint64_t_val, 90); + svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); + svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_z(svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + sveor3(svint8_t_val, svint8_t_val, int8_t_val); + sveor3(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3(svint16_t_val, svint16_t_val, int16_t_val); + sveor3(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3(svint32_t_val, svint32_t_val, int32_t_val); + sveor3(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3(svint64_t_val, svint64_t_val, int64_t_val); + sveor3(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svint8_t_val, svint8_t_val, int8_t_val); + sveortb(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb(svint16_t_val, svint16_t_val, int16_t_val); + sveortb(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb(svint32_t_val, svint32_t_val, int32_t_val); + sveortb(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb(svint64_t_val, svint64_t_val, int64_t_val); + sveortb(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_f16_x(svbool_t_val, svfloat16_t_val); + svlogb_f16_z(svbool_t_val, svfloat16_t_val); + svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_f32_x(svbool_t_val, svfloat32_t_val); + svlogb_f32_z(svbool_t_val, svfloat32_t_val); + svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_f64_x(svbool_t_val, svfloat64_t_val); + svlogb_f64_z(svbool_t_val, svfloat64_t_val); + svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_x(svbool_t_val, svfloat16_t_val); + svlogb_x(svbool_t_val, svfloat32_t_val); + svlogb_x(svbool_t_val, svfloat64_t_val); + svlogb_z(svbool_t_val, svfloat16_t_val); + svlogb_z(svbool_t_val, svfloat32_t_val); + svlogb_z(svbool_t_val, svfloat64_t_val); + svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmovlb(svint8_t_val); + svmovlb(svint16_t_val); + svmovlb(svint32_t_val); + svmovlb(svuint8_t_val); + svmovlb(svuint16_t_val); + svmovlb(svuint32_t_val); + svmovlb_s16(svint8_t_val); + svmovlb_s32(svint16_t_val); + svmovlb_s64(svint32_t_val); + svmovlb_u16(svuint8_t_val); + svmovlb_u32(svuint16_t_val); + svmovlb_u64(svuint32_t_val); + svmovlt(svint8_t_val); + svmovlt(svint16_t_val); + svmovlt(svint32_t_val); + svmovlt(svuint8_t_val); + svmovlt(svuint16_t_val); + svmovlt(svuint32_t_val); + svmovlt_s16(svint8_t_val); + svmovlt_s32(svint16_t_val); + svmovlt_s64(svint32_t_val); + svmovlt_u16(svuint8_t_val); + svmovlt_u32(svuint16_t_val); + svmovlt_u64(svuint32_t_val); + svmul_lane(svint16_t_val, svint16_t_val, 1); + svmul_lane(svint32_t_val, svint32_t_val, 1); + svmul_lane(svint64_t_val, svint64_t_val, 1); + svmul_lane(svuint16_t_val, svuint16_t_val, 1); + svmul_lane(svuint32_t_val, svuint32_t_val, 1); + svmul_lane(svuint64_t_val, svuint64_t_val, 1); + svmul_lane_s16(svint16_t_val, svint16_t_val, 1); + svmul_lane_s32(svint32_t_val, svint32_t_val, 1); + svmul_lane_s64(svint64_t_val, svint64_t_val, 1); + svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); + svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); + svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); + svmullb(svint8_t_val, int8_t_val); + svmullb(svint8_t_val, svint8_t_val); + svmullb(svint16_t_val, int16_t_val); + svmullb(svint16_t_val, svint16_t_val); + svmullb(svint32_t_val, int32_t_val); + svmullb(svint32_t_val, svint32_t_val); + svmullb(svuint8_t_val, svuint8_t_val); + svmullb(svuint8_t_val, uint8_t_val); + svmullb(svuint16_t_val, svuint16_t_val); + svmullb(svuint16_t_val, uint16_t_val); + svmullb(svuint32_t_val, svuint32_t_val); + svmullb(svuint32_t_val, uint32_t_val); + svmullb_lane(svint16_t_val, svint16_t_val, 1); + svmullb_lane(svint32_t_val, svint32_t_val, 1); + svmullb_lane(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane(svuint32_t_val, svuint32_t_val, 1); + svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullb_n_s16(svint8_t_val, int8_t_val); + svmullb_n_s32(svint16_t_val, int16_t_val); + svmullb_n_s64(svint32_t_val, int32_t_val); + svmullb_n_u16(svuint8_t_val, uint8_t_val); + svmullb_n_u32(svuint16_t_val, uint16_t_val); + svmullb_n_u64(svuint32_t_val, uint32_t_val); + svmullb_s16(svint8_t_val, svint8_t_val); + svmullb_s32(svint16_t_val, svint16_t_val); + svmullb_s64(svint32_t_val, svint32_t_val); + svmullb_u16(svuint8_t_val, svuint8_t_val); + svmullb_u32(svuint16_t_val, svuint16_t_val); + svmullb_u64(svuint32_t_val, svuint32_t_val); + svmullt(svint8_t_val, int8_t_val); + svmullt(svint8_t_val, svint8_t_val); + svmullt(svint16_t_val, int16_t_val); + svmullt(svint16_t_val, svint16_t_val); + svmullt(svint32_t_val, int32_t_val); + svmullt(svint32_t_val, svint32_t_val); + svmullt(svuint8_t_val, svuint8_t_val); + svmullt(svuint8_t_val, uint8_t_val); + svmullt(svuint16_t_val, svuint16_t_val); + svmullt(svuint16_t_val, uint16_t_val); + svmullt(svuint32_t_val, svuint32_t_val); + svmullt(svuint32_t_val, uint32_t_val); + svmullt_lane(svint16_t_val, svint16_t_val, 1); + svmullt_lane(svint32_t_val, svint32_t_val, 1); + svmullt_lane(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane(svuint32_t_val, svuint32_t_val, 1); + svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullt_n_s16(svint8_t_val, int8_t_val); + svmullt_n_s32(svint16_t_val, int16_t_val); + svmullt_n_s64(svint32_t_val, int32_t_val); + svmullt_n_u16(svuint8_t_val, uint8_t_val); + svmullt_n_u32(svuint16_t_val, uint16_t_val); + svmullt_n_u64(svuint32_t_val, uint32_t_val); + svmullt_s16(svint8_t_val, svint8_t_val); + svmullt_s32(svint16_t_val, svint16_t_val); + svmullt_s64(svint32_t_val, svint32_t_val); + svmullt_u16(svuint8_t_val, svuint8_t_val); + svmullt_u32(svuint16_t_val, svuint16_t_val); + svmullt_u64(svuint32_t_val, svuint32_t_val); + svnbsl(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpmul(svuint8_t_val, svuint8_t_val); + svpmul(svuint8_t_val, uint8_t_val); + svpmul_n_u8(svuint8_t_val, uint8_t_val); + svpmul_u8(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, uint8_t_val); + svpmullb(svuint32_t_val, svuint32_t_val); + svpmullb(svuint32_t_val, uint32_t_val); + svpmullb_n_u16(svuint8_t_val, uint8_t_val); + svpmullb_n_u64(svuint32_t_val, uint32_t_val); + svpmullb_pair(svuint8_t_val, svuint8_t_val); + svpmullb_pair(svuint8_t_val, uint8_t_val); + svpmullb_pair(svuint32_t_val, svuint32_t_val); + svpmullb_pair(svuint32_t_val, uint32_t_val); + svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullb_u16(svuint8_t_val, svuint8_t_val); + svpmullb_u64(svuint32_t_val, svuint32_t_val); + svpmullt(svuint8_t_val, svuint8_t_val); + svpmullt(svuint8_t_val, uint8_t_val); + svpmullt(svuint32_t_val, svuint32_t_val); + svpmullt(svuint32_t_val, uint32_t_val); + svpmullt_n_u16(svuint8_t_val, uint8_t_val); + svpmullt_n_u64(svuint32_t_val, uint32_t_val); + svpmullt_pair(svuint8_t_val, svuint8_t_val); + svpmullt_pair(svuint8_t_val, uint8_t_val); + svpmullt_pair(svuint32_t_val, svuint32_t_val); + svpmullt_pair(svuint32_t_val, uint32_t_val); + svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullt_u16(svuint8_t_val, svuint8_t_val); + svpmullt_u64(svuint32_t_val, svuint32_t_val); + svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_s8_x(svbool_t_val, svint8_t_val); + svqabs_s8_z(svbool_t_val, svint8_t_val); + svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_s16_x(svbool_t_val, svint16_t_val); + svqabs_s16_z(svbool_t_val, svint16_t_val); + svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_s32_x(svbool_t_val, svint32_t_val); + svqabs_s32_z(svbool_t_val, svint32_t_val); + svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s64_x(svbool_t_val, svint64_t_val); + svqabs_s64_z(svbool_t_val, svint64_t_val); + svqabs_x(svbool_t_val, svint8_t_val); + svqabs_x(svbool_t_val, svint16_t_val); + svqabs_x(svbool_t_val, svint32_t_val); + svqabs_x(svbool_t_val, svint64_t_val); + svqabs_z(svbool_t_val, svint8_t_val); + svqabs_z(svbool_t_val, svint16_t_val); + svqabs_z(svbool_t_val, svint32_t_val); + svqabs_z(svbool_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqcadd(svint8_t_val, svint8_t_val, 90); + svqcadd(svint16_t_val, svint16_t_val, 90); + svqcadd(svint32_t_val, svint32_t_val, 90); + svqcadd(svint64_t_val, svint64_t_val, 90); + svqcadd_s8(svint8_t_val, svint8_t_val, 90); + svqcadd_s16(svint16_t_val, svint16_t_val, 90); + svqcadd_s32(svint32_t_val, svint32_t_val, 90); + svqcadd_s64(svint64_t_val, svint64_t_val, 90); + svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmulh(svint8_t_val, int8_t_val); + svqdmulh(svint8_t_val, svint8_t_val); + svqdmulh(svint16_t_val, int16_t_val); + svqdmulh(svint16_t_val, svint16_t_val); + svqdmulh(svint32_t_val, int32_t_val); + svqdmulh(svint32_t_val, svint32_t_val); + svqdmulh(svint64_t_val, int64_t_val); + svqdmulh(svint64_t_val, svint64_t_val); + svqdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqdmulh_n_s8(svint8_t_val, int8_t_val); + svqdmulh_n_s16(svint16_t_val, int16_t_val); + svqdmulh_n_s32(svint32_t_val, int32_t_val); + svqdmulh_n_s64(svint64_t_val, int64_t_val); + svqdmulh_s8(svint8_t_val, svint8_t_val); + svqdmulh_s16(svint16_t_val, svint16_t_val); + svqdmulh_s32(svint32_t_val, svint32_t_val); + svqdmulh_s64(svint64_t_val, svint64_t_val); + svqdmullb(svint8_t_val, int8_t_val); + svqdmullb(svint8_t_val, svint8_t_val); + svqdmullb(svint16_t_val, int16_t_val); + svqdmullb(svint16_t_val, svint16_t_val); + svqdmullb(svint32_t_val, int32_t_val); + svqdmullb(svint32_t_val, svint32_t_val); + svqdmullb_lane(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane(svint32_t_val, svint32_t_val, 1); + svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullb_n_s16(svint8_t_val, int8_t_val); + svqdmullb_n_s32(svint16_t_val, int16_t_val); + svqdmullb_n_s64(svint32_t_val, int32_t_val); + svqdmullb_s16(svint8_t_val, svint8_t_val); + svqdmullb_s32(svint16_t_val, svint16_t_val); + svqdmullb_s64(svint32_t_val, svint32_t_val); + svqdmullt(svint8_t_val, int8_t_val); + svqdmullt(svint8_t_val, svint8_t_val); + svqdmullt(svint16_t_val, int16_t_val); + svqdmullt(svint16_t_val, svint16_t_val); + svqdmullt(svint32_t_val, int32_t_val); + svqdmullt(svint32_t_val, svint32_t_val); + svqdmullt_lane(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane(svint32_t_val, svint32_t_val, 1); + svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullt_n_s16(svint8_t_val, int8_t_val); + svqdmullt_n_s32(svint16_t_val, int16_t_val); + svqdmullt_n_s64(svint32_t_val, int32_t_val); + svqdmullt_s16(svint8_t_val, svint8_t_val); + svqdmullt_s32(svint16_t_val, svint16_t_val); + svqdmullt_s64(svint32_t_val, svint32_t_val); + svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_s8_x(svbool_t_val, svint8_t_val); + svqneg_s8_z(svbool_t_val, svint8_t_val); + svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_s16_x(svbool_t_val, svint16_t_val); + svqneg_s16_z(svbool_t_val, svint16_t_val); + svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_s32_x(svbool_t_val, svint32_t_val); + svqneg_s32_z(svbool_t_val, svint32_t_val); + svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s64_x(svbool_t_val, svint64_t_val); + svqneg_s64_z(svbool_t_val, svint64_t_val); + svqneg_x(svbool_t_val, svint8_t_val); + svqneg_x(svbool_t_val, svint16_t_val); + svqneg_x(svbool_t_val, svint32_t_val); + svqneg_x(svbool_t_val, svint64_t_val); + svqneg_z(svbool_t_val, svint8_t_val); + svqneg_z(svbool_t_val, svint16_t_val); + svqneg_z(svbool_t_val, svint32_t_val); + svqneg_z(svbool_t_val, svint64_t_val); + svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmulh(svint8_t_val, int8_t_val); + svqrdmulh(svint8_t_val, svint8_t_val); + svqrdmulh(svint16_t_val, int16_t_val); + svqrdmulh(svint16_t_val, svint16_t_val); + svqrdmulh(svint32_t_val, int32_t_val); + svqrdmulh(svint32_t_val, svint32_t_val); + svqrdmulh(svint64_t_val, int64_t_val); + svqrdmulh(svint64_t_val, svint64_t_val); + svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqrdmulh_n_s8(svint8_t_val, int8_t_val); + svqrdmulh_n_s16(svint16_t_val, int16_t_val); + svqrdmulh_n_s32(svint32_t_val, int32_t_val); + svqrdmulh_n_s64(svint64_t_val, int64_t_val); + svqrdmulh_s8(svint8_t_val, svint8_t_val); + svqrdmulh_s16(svint16_t_val, svint16_t_val); + svqrdmulh_s32(svint32_t_val, svint32_t_val); + svqrdmulh_s64(svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshrnb(svint16_t_val, 2); + svqrshrnb(svint32_t_val, 2); + svqrshrnb(svint64_t_val, 2); + svqrshrnb(svuint16_t_val, 2); + svqrshrnb(svuint32_t_val, 2); + svqrshrnb(svuint64_t_val, 2); + svqrshrnb_n_s16(svint16_t_val, 2); + svqrshrnb_n_s32(svint32_t_val, 2); + svqrshrnb_n_s64(svint64_t_val, 2); + svqrshrnb_n_u16(svuint16_t_val, 2); + svqrshrnb_n_u32(svuint32_t_val, 2); + svqrshrnb_n_u64(svuint64_t_val, 2); + svqrshrnt(svint8_t_val, svint16_t_val, 2); + svqrshrnt(svint16_t_val, svint32_t_val, 2); + svqrshrnt(svint32_t_val, svint64_t_val, 2); + svqrshrnt(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt(svuint32_t_val, svuint64_t_val, 2); + svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqrshrunb(svint16_t_val, 2); + svqrshrunb(svint32_t_val, 2); + svqrshrunb(svint64_t_val, 2); + svqrshrunb_n_s16(svint16_t_val, 2); + svqrshrunb_n_s32(svint32_t_val, 2); + svqrshrunb_n_s64(svint64_t_val, 2); + svqrshrunt(svuint8_t_val, svint16_t_val, 2); + svqrshrunt(svuint16_t_val, svint32_t_val, 2); + svqrshrunt(svuint32_t_val, svint64_t_val, 2); + svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshlu_m(svbool_t_val, svint8_t_val, 2); + svqshlu_m(svbool_t_val, svint16_t_val, 2); + svqshlu_m(svbool_t_val, svint32_t_val, 2); + svqshlu_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); + svqshlu_x(svbool_t_val, svint8_t_val, 2); + svqshlu_x(svbool_t_val, svint16_t_val, 2); + svqshlu_x(svbool_t_val, svint32_t_val, 2); + svqshlu_x(svbool_t_val, svint64_t_val, 2); + svqshlu_z(svbool_t_val, svint8_t_val, 2); + svqshlu_z(svbool_t_val, svint16_t_val, 2); + svqshlu_z(svbool_t_val, svint32_t_val, 2); + svqshlu_z(svbool_t_val, svint64_t_val, 2); + svqshrnb(svint16_t_val, 2); + svqshrnb(svint32_t_val, 2); + svqshrnb(svint64_t_val, 2); + svqshrnb(svuint16_t_val, 2); + svqshrnb(svuint32_t_val, 2); + svqshrnb(svuint64_t_val, 2); + svqshrnb_n_s16(svint16_t_val, 2); + svqshrnb_n_s32(svint32_t_val, 2); + svqshrnb_n_s64(svint64_t_val, 2); + svqshrnb_n_u16(svuint16_t_val, 2); + svqshrnb_n_u32(svuint32_t_val, 2); + svqshrnb_n_u64(svuint64_t_val, 2); + svqshrnt(svint8_t_val, svint16_t_val, 2); + svqshrnt(svint16_t_val, svint32_t_val, 2); + svqshrnt(svint32_t_val, svint64_t_val, 2); + svqshrnt(svuint8_t_val, svuint16_t_val, 2); + svqshrnt(svuint16_t_val, svuint32_t_val, 2); + svqshrnt(svuint32_t_val, svuint64_t_val, 2); + svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqshrunb(svint16_t_val, 2); + svqshrunb(svint32_t_val, 2); + svqshrunb(svint64_t_val, 2); + svqshrunb_n_s16(svint16_t_val, 2); + svqshrunb_n_s32(svint32_t_val, 2); + svqshrunb_n_s64(svint64_t_val, 2); + svqshrunt(svuint8_t_val, svint16_t_val, 2); + svqshrunt(svuint16_t_val, svint32_t_val, 2); + svqshrunt(svuint32_t_val, svint64_t_val, 2); + svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqxtnb(svint16_t_val); + svqxtnb(svint32_t_val); + svqxtnb(svint64_t_val); + svqxtnb(svuint16_t_val); + svqxtnb(svuint32_t_val); + svqxtnb(svuint64_t_val); + svqxtnb_s16(svint16_t_val); + svqxtnb_s32(svint32_t_val); + svqxtnb_s64(svint64_t_val); + svqxtnb_u16(svuint16_t_val); + svqxtnb_u32(svuint32_t_val); + svqxtnb_u64(svuint64_t_val); + svqxtnt(svint8_t_val, svint16_t_val); + svqxtnt(svint16_t_val, svint32_t_val); + svqxtnt(svint32_t_val, svint64_t_val); + svqxtnt(svuint8_t_val, svuint16_t_val); + svqxtnt(svuint16_t_val, svuint32_t_val); + svqxtnt(svuint32_t_val, svuint64_t_val); + svqxtnt_s16(svint8_t_val, svint16_t_val); + svqxtnt_s32(svint16_t_val, svint32_t_val); + svqxtnt_s64(svint32_t_val, svint64_t_val); + svqxtnt_u16(svuint8_t_val, svuint16_t_val); + svqxtnt_u32(svuint16_t_val, svuint32_t_val); + svqxtnt_u64(svuint32_t_val, svuint64_t_val); + svqxtunb(svint16_t_val); + svqxtunb(svint32_t_val); + svqxtunb(svint64_t_val); + svqxtunb_s16(svint16_t_val); + svqxtunb_s32(svint32_t_val); + svqxtunb_s64(svint64_t_val); + svqxtunt(svuint8_t_val, svint16_t_val); + svqxtunt(svuint16_t_val, svint32_t_val); + svqxtunt(svuint32_t_val, svint64_t_val); + svqxtunt_s16(svuint8_t_val, svint16_t_val); + svqxtunt_s32(svuint16_t_val, svint32_t_val); + svqxtunt_s64(svuint32_t_val, svint64_t_val); + svraddhnb(svint16_t_val, int16_t_val); + svraddhnb(svint16_t_val, svint16_t_val); + svraddhnb(svint32_t_val, int32_t_val); + svraddhnb(svint32_t_val, svint32_t_val); + svraddhnb(svint64_t_val, int64_t_val); + svraddhnb(svint64_t_val, svint64_t_val); + svraddhnb(svuint16_t_val, svuint16_t_val); + svraddhnb(svuint16_t_val, uint16_t_val); + svraddhnb(svuint32_t_val, svuint32_t_val); + svraddhnb(svuint32_t_val, uint32_t_val); + svraddhnb(svuint64_t_val, svuint64_t_val); + svraddhnb(svuint64_t_val, uint64_t_val); + svraddhnb_n_s16(svint16_t_val, int16_t_val); + svraddhnb_n_s32(svint32_t_val, int32_t_val); + svraddhnb_n_s64(svint64_t_val, int64_t_val); + svraddhnb_n_u16(svuint16_t_val, uint16_t_val); + svraddhnb_n_u32(svuint32_t_val, uint32_t_val); + svraddhnb_n_u64(svuint64_t_val, uint64_t_val); + svraddhnb_s16(svint16_t_val, svint16_t_val); + svraddhnb_s32(svint32_t_val, svint32_t_val); + svraddhnb_s64(svint64_t_val, svint64_t_val); + svraddhnb_u16(svuint16_t_val, svuint16_t_val); + svraddhnb_u32(svuint32_t_val, svuint32_t_val); + svraddhnb_u64(svuint64_t_val, svuint64_t_val); + svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_x(svbool_t_val, svuint32_t_val); + svrecpe_u32_z(svbool_t_val, svuint32_t_val); + svrecpe_x(svbool_t_val, svuint32_t_val); + svrecpe_z(svbool_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshr_m(svbool_t_val, svint8_t_val, 2); + svrshr_m(svbool_t_val, svint16_t_val, 2); + svrshr_m(svbool_t_val, svint32_t_val, 2); + svrshr_m(svbool_t_val, svint64_t_val, 2); + svrshr_m(svbool_t_val, svuint8_t_val, 2); + svrshr_m(svbool_t_val, svuint16_t_val, 2); + svrshr_m(svbool_t_val, svuint32_t_val, 2); + svrshr_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); + svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); + svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); + svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); + svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); + svrshr_x(svbool_t_val, svint8_t_val, 2); + svrshr_x(svbool_t_val, svint16_t_val, 2); + svrshr_x(svbool_t_val, svint32_t_val, 2); + svrshr_x(svbool_t_val, svint64_t_val, 2); + svrshr_x(svbool_t_val, svuint8_t_val, 2); + svrshr_x(svbool_t_val, svuint16_t_val, 2); + svrshr_x(svbool_t_val, svuint32_t_val, 2); + svrshr_x(svbool_t_val, svuint64_t_val, 2); + svrshr_z(svbool_t_val, svint8_t_val, 2); + svrshr_z(svbool_t_val, svint16_t_val, 2); + svrshr_z(svbool_t_val, svint32_t_val, 2); + svrshr_z(svbool_t_val, svint64_t_val, 2); + svrshr_z(svbool_t_val, svuint8_t_val, 2); + svrshr_z(svbool_t_val, svuint16_t_val, 2); + svrshr_z(svbool_t_val, svuint32_t_val, 2); + svrshr_z(svbool_t_val, svuint64_t_val, 2); + svrshrnb(svint16_t_val, 2); + svrshrnb(svint32_t_val, 2); + svrshrnb(svint64_t_val, 2); + svrshrnb(svuint16_t_val, 2); + svrshrnb(svuint32_t_val, 2); + svrshrnb(svuint64_t_val, 2); + svrshrnb_n_s16(svint16_t_val, 2); + svrshrnb_n_s32(svint32_t_val, 2); + svrshrnb_n_s64(svint64_t_val, 2); + svrshrnb_n_u16(svuint16_t_val, 2); + svrshrnb_n_u32(svuint32_t_val, 2); + svrshrnb_n_u64(svuint64_t_val, 2); + svrshrnt(svint8_t_val, svint16_t_val, 2); + svrshrnt(svint16_t_val, svint32_t_val, 2); + svrshrnt(svint32_t_val, svint64_t_val, 2); + svrshrnt(svuint8_t_val, svuint16_t_val, 2); + svrshrnt(svuint16_t_val, svuint32_t_val, 2); + svrshrnt(svuint32_t_val, svuint64_t_val, 2); + svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_x(svbool_t_val, svuint32_t_val); + svrsqrte_u32_z(svbool_t_val, svuint32_t_val); + svrsqrte_x(svbool_t_val, svuint32_t_val); + svrsqrte_z(svbool_t_val, svuint32_t_val); + svrsra(svint8_t_val, svint8_t_val, 2); + svrsra(svint16_t_val, svint16_t_val, 2); + svrsra(svint32_t_val, svint32_t_val, 2); + svrsra(svint64_t_val, svint64_t_val, 2); + svrsra(svuint8_t_val, svuint8_t_val, 2); + svrsra(svuint16_t_val, svuint16_t_val, 2); + svrsra(svuint32_t_val, svuint32_t_val, 2); + svrsra(svuint64_t_val, svuint64_t_val, 2); + svrsra_n_s8(svint8_t_val, svint8_t_val, 2); + svrsra_n_s16(svint16_t_val, svint16_t_val, 2); + svrsra_n_s32(svint32_t_val, svint32_t_val, 2); + svrsra_n_s64(svint64_t_val, svint64_t_val, 2); + svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svrsubhnb(svint16_t_val, int16_t_val); + svrsubhnb(svint16_t_val, svint16_t_val); + svrsubhnb(svint32_t_val, int32_t_val); + svrsubhnb(svint32_t_val, svint32_t_val); + svrsubhnb(svint64_t_val, int64_t_val); + svrsubhnb(svint64_t_val, svint64_t_val); + svrsubhnb(svuint16_t_val, svuint16_t_val); + svrsubhnb(svuint16_t_val, uint16_t_val); + svrsubhnb(svuint32_t_val, svuint32_t_val); + svrsubhnb(svuint32_t_val, uint32_t_val); + svrsubhnb(svuint64_t_val, svuint64_t_val); + svrsubhnb(svuint64_t_val, uint64_t_val); + svrsubhnb_n_s16(svint16_t_val, int16_t_val); + svrsubhnb_n_s32(svint32_t_val, int32_t_val); + svrsubhnb_n_s64(svint64_t_val, int64_t_val); + svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svrsubhnb_s16(svint16_t_val, svint16_t_val); + svrsubhnb_s32(svint32_t_val, svint32_t_val); + svrsubhnb_s64(svint64_t_val, svint64_t_val); + svrsubhnb_u16(svuint16_t_val, svuint16_t_val); + svrsubhnb_u32(svuint32_t_val, svuint32_t_val); + svrsubhnb_u64(svuint64_t_val, svuint64_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svshllb(svint8_t_val, 2); + svshllb(svint16_t_val, 2); + svshllb(svint32_t_val, 2); + svshllb(svuint8_t_val, 2); + svshllb(svuint16_t_val, 2); + svshllb(svuint32_t_val, 2); + svshllb_n_s16(svint8_t_val, 2); + svshllb_n_s32(svint16_t_val, 2); + svshllb_n_s64(svint32_t_val, 2); + svshllb_n_u16(svuint8_t_val, 2); + svshllb_n_u32(svuint16_t_val, 2); + svshllb_n_u64(svuint32_t_val, 2); + svshllt(svint8_t_val, 2); + svshllt(svint16_t_val, 2); + svshllt(svint32_t_val, 2); + svshllt(svuint8_t_val, 2); + svshllt(svuint16_t_val, 2); + svshllt(svuint32_t_val, 2); + svshllt_n_s16(svint8_t_val, 2); + svshllt_n_s32(svint16_t_val, 2); + svshllt_n_s64(svint32_t_val, 2); + svshllt_n_u16(svuint8_t_val, 2); + svshllt_n_u32(svuint16_t_val, 2); + svshllt_n_u64(svuint32_t_val, 2); + svshrnb(svint16_t_val, 2); + svshrnb(svint32_t_val, 2); + svshrnb(svint64_t_val, 2); + svshrnb(svuint16_t_val, 2); + svshrnb(svuint32_t_val, 2); + svshrnb(svuint64_t_val, 2); + svshrnb_n_s16(svint16_t_val, 2); + svshrnb_n_s32(svint32_t_val, 2); + svshrnb_n_s64(svint64_t_val, 2); + svshrnb_n_u16(svuint16_t_val, 2); + svshrnb_n_u32(svuint32_t_val, 2); + svshrnb_n_u64(svuint64_t_val, 2); + svshrnt(svint8_t_val, svint16_t_val, 2); + svshrnt(svint16_t_val, svint32_t_val, 2); + svshrnt(svint32_t_val, svint64_t_val, 2); + svshrnt(svuint8_t_val, svuint16_t_val, 2); + svshrnt(svuint16_t_val, svuint32_t_val, 2); + svshrnt(svuint32_t_val, svuint64_t_val, 2); + svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svsli(svint8_t_val, svint8_t_val, 2); + svsli(svint16_t_val, svint16_t_val, 2); + svsli(svint32_t_val, svint32_t_val, 2); + svsli(svint64_t_val, svint64_t_val, 2); + svsli(svuint8_t_val, svuint8_t_val, 2); + svsli(svuint16_t_val, svuint16_t_val, 2); + svsli(svuint32_t_val, svuint32_t_val, 2); + svsli(svuint64_t_val, svuint64_t_val, 2); + svsli_n_s8(svint8_t_val, svint8_t_val, 2); + svsli_n_s16(svint16_t_val, svint16_t_val, 2); + svsli_n_s32(svint32_t_val, svint32_t_val, 2); + svsli_n_s64(svint64_t_val, svint64_t_val, 2); + svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsra(svint8_t_val, svint8_t_val, 2); + svsra(svint16_t_val, svint16_t_val, 2); + svsra(svint32_t_val, svint32_t_val, 2); + svsra(svint64_t_val, svint64_t_val, 2); + svsra(svuint8_t_val, svuint8_t_val, 2); + svsra(svuint16_t_val, svuint16_t_val, 2); + svsra(svuint32_t_val, svuint32_t_val, 2); + svsra(svuint64_t_val, svuint64_t_val, 2); + svsra_n_s8(svint8_t_val, svint8_t_val, 2); + svsra_n_s16(svint16_t_val, svint16_t_val, 2); + svsra_n_s32(svint32_t_val, svint32_t_val, 2); + svsra_n_s64(svint64_t_val, svint64_t_val, 2); + svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsri(svint8_t_val, svint8_t_val, 2); + svsri(svint16_t_val, svint16_t_val, 2); + svsri(svint32_t_val, svint32_t_val, 2); + svsri(svint64_t_val, svint64_t_val, 2); + svsri(svuint8_t_val, svuint8_t_val, 2); + svsri(svuint16_t_val, svuint16_t_val, 2); + svsri(svuint32_t_val, svuint32_t_val, 2); + svsri(svuint64_t_val, svuint64_t_val, 2); + svsri_n_s8(svint8_t_val, svint8_t_val, 2); + svsri_n_s16(svint16_t_val, svint16_t_val, 2); + svsri_n_s32(svint32_t_val, svint32_t_val, 2); + svsri_n_s64(svint64_t_val, svint64_t_val, 2); + svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsubhnb(svint16_t_val, int16_t_val); + svsubhnb(svint16_t_val, svint16_t_val); + svsubhnb(svint32_t_val, int32_t_val); + svsubhnb(svint32_t_val, svint32_t_val); + svsubhnb(svint64_t_val, int64_t_val); + svsubhnb(svint64_t_val, svint64_t_val); + svsubhnb(svuint16_t_val, svuint16_t_val); + svsubhnb(svuint16_t_val, uint16_t_val); + svsubhnb(svuint32_t_val, svuint32_t_val); + svsubhnb(svuint32_t_val, uint32_t_val); + svsubhnb(svuint64_t_val, svuint64_t_val); + svsubhnb(svuint64_t_val, uint64_t_val); + svsubhnb_n_s16(svint16_t_val, int16_t_val); + svsubhnb_n_s32(svint32_t_val, int32_t_val); + svsubhnb_n_s64(svint64_t_val, int64_t_val); + svsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svsubhnb_s16(svint16_t_val, svint16_t_val); + svsubhnb_s32(svint32_t_val, svint32_t_val); + svsubhnb_s64(svint64_t_val, svint64_t_val); + svsubhnb_u16(svuint16_t_val, svuint16_t_val); + svsubhnb_u32(svuint32_t_val, svuint32_t_val); + svsubhnb_u64(svuint64_t_val, svuint64_t_val); + svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsublb(svint8_t_val, int8_t_val); + svsublb(svint8_t_val, svint8_t_val); + svsublb(svint16_t_val, int16_t_val); + svsublb(svint16_t_val, svint16_t_val); + svsublb(svint32_t_val, int32_t_val); + svsublb(svint32_t_val, svint32_t_val); + svsublb(svuint8_t_val, svuint8_t_val); + svsublb(svuint8_t_val, uint8_t_val); + svsublb(svuint16_t_val, svuint16_t_val); + svsublb(svuint16_t_val, uint16_t_val); + svsublb(svuint32_t_val, svuint32_t_val); + svsublb(svuint32_t_val, uint32_t_val); + svsublb_n_s16(svint8_t_val, int8_t_val); + svsublb_n_s32(svint16_t_val, int16_t_val); + svsublb_n_s64(svint32_t_val, int32_t_val); + svsublb_n_u16(svuint8_t_val, uint8_t_val); + svsublb_n_u32(svuint16_t_val, uint16_t_val); + svsublb_n_u64(svuint32_t_val, uint32_t_val); + svsublb_s16(svint8_t_val, svint8_t_val); + svsublb_s32(svint16_t_val, svint16_t_val); + svsublb_s64(svint32_t_val, svint32_t_val); + svsublb_u16(svuint8_t_val, svuint8_t_val); + svsublb_u32(svuint16_t_val, svuint16_t_val); + svsublb_u64(svuint32_t_val, svuint32_t_val); + svsublbt(svint8_t_val, int8_t_val); + svsublbt(svint8_t_val, svint8_t_val); + svsublbt(svint16_t_val, int16_t_val); + svsublbt(svint16_t_val, svint16_t_val); + svsublbt(svint32_t_val, int32_t_val); + svsublbt(svint32_t_val, svint32_t_val); + svsublbt_n_s16(svint8_t_val, int8_t_val); + svsublbt_n_s32(svint16_t_val, int16_t_val); + svsublbt_n_s64(svint32_t_val, int32_t_val); + svsublbt_s16(svint8_t_val, svint8_t_val); + svsublbt_s32(svint16_t_val, svint16_t_val); + svsublbt_s64(svint32_t_val, svint32_t_val); + svsublt(svint8_t_val, int8_t_val); + svsublt(svint8_t_val, svint8_t_val); + svsublt(svint16_t_val, int16_t_val); + svsublt(svint16_t_val, svint16_t_val); + svsublt(svint32_t_val, int32_t_val); + svsublt(svint32_t_val, svint32_t_val); + svsublt(svuint8_t_val, svuint8_t_val); + svsublt(svuint8_t_val, uint8_t_val); + svsublt(svuint16_t_val, svuint16_t_val); + svsublt(svuint16_t_val, uint16_t_val); + svsublt(svuint32_t_val, svuint32_t_val); + svsublt(svuint32_t_val, uint32_t_val); + svsublt_n_s16(svint8_t_val, int8_t_val); + svsublt_n_s32(svint16_t_val, int16_t_val); + svsublt_n_s64(svint32_t_val, int32_t_val); + svsublt_n_u16(svuint8_t_val, uint8_t_val); + svsublt_n_u32(svuint16_t_val, uint16_t_val); + svsublt_n_u64(svuint32_t_val, uint32_t_val); + svsublt_s16(svint8_t_val, svint8_t_val); + svsublt_s32(svint16_t_val, svint16_t_val); + svsublt_s64(svint32_t_val, svint32_t_val); + svsublt_u16(svuint8_t_val, svuint8_t_val); + svsublt_u32(svuint16_t_val, svuint16_t_val); + svsublt_u64(svuint32_t_val, svuint32_t_val); + svsubltb(svint8_t_val, int8_t_val); + svsubltb(svint8_t_val, svint8_t_val); + svsubltb(svint16_t_val, int16_t_val); + svsubltb(svint16_t_val, svint16_t_val); + svsubltb(svint32_t_val, int32_t_val); + svsubltb(svint32_t_val, svint32_t_val); + svsubltb_n_s16(svint8_t_val, int8_t_val); + svsubltb_n_s32(svint16_t_val, int16_t_val); + svsubltb_n_s64(svint32_t_val, int32_t_val); + svsubltb_s16(svint8_t_val, svint8_t_val); + svsubltb_s32(svint16_t_val, svint16_t_val); + svsubltb_s64(svint32_t_val, svint32_t_val); + svsubwb(svint16_t_val, int8_t_val); + svsubwb(svint16_t_val, svint8_t_val); + svsubwb(svint32_t_val, int16_t_val); + svsubwb(svint32_t_val, svint16_t_val); + svsubwb(svint64_t_val, int32_t_val); + svsubwb(svint64_t_val, svint32_t_val); + svsubwb(svuint16_t_val, svuint8_t_val); + svsubwb(svuint16_t_val, uint8_t_val); + svsubwb(svuint32_t_val, svuint16_t_val); + svsubwb(svuint32_t_val, uint16_t_val); + svsubwb(svuint64_t_val, svuint32_t_val); + svsubwb(svuint64_t_val, uint32_t_val); + svsubwb_n_s16(svint16_t_val, int8_t_val); + svsubwb_n_s32(svint32_t_val, int16_t_val); + svsubwb_n_s64(svint64_t_val, int32_t_val); + svsubwb_n_u16(svuint16_t_val, uint8_t_val); + svsubwb_n_u32(svuint32_t_val, uint16_t_val); + svsubwb_n_u64(svuint64_t_val, uint32_t_val); + svsubwb_s16(svint16_t_val, svint8_t_val); + svsubwb_s32(svint32_t_val, svint16_t_val); + svsubwb_s64(svint64_t_val, svint32_t_val); + svsubwb_u16(svuint16_t_val, svuint8_t_val); + svsubwb_u32(svuint32_t_val, svuint16_t_val); + svsubwb_u64(svuint64_t_val, svuint32_t_val); + svsubwt(svint16_t_val, int8_t_val); + svsubwt(svint16_t_val, svint8_t_val); + svsubwt(svint32_t_val, int16_t_val); + svsubwt(svint32_t_val, svint16_t_val); + svsubwt(svint64_t_val, int32_t_val); + svsubwt(svint64_t_val, svint32_t_val); + svsubwt(svuint16_t_val, svuint8_t_val); + svsubwt(svuint16_t_val, uint8_t_val); + svsubwt(svuint32_t_val, svuint16_t_val); + svsubwt(svuint32_t_val, uint16_t_val); + svsubwt(svuint64_t_val, svuint32_t_val); + svsubwt(svuint64_t_val, uint32_t_val); + svsubwt_n_s16(svint16_t_val, int8_t_val); + svsubwt_n_s32(svint32_t_val, int16_t_val); + svsubwt_n_s64(svint64_t_val, int32_t_val); + svsubwt_n_u16(svuint16_t_val, uint8_t_val); + svsubwt_n_u32(svuint32_t_val, uint16_t_val); + svsubwt_n_u64(svuint64_t_val, uint32_t_val); + svsubwt_s16(svint16_t_val, svint8_t_val); + svsubwt_s32(svint32_t_val, svint16_t_val); + svsubwt_s64(svint64_t_val, svint32_t_val); + svsubwt_u16(svuint16_t_val, svuint8_t_val); + svsubwt_u32(svuint32_t_val, svuint16_t_val); + svsubwt_u64(svuint64_t_val, svuint32_t_val); + svtbl2(svbfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat32x2_t_val, svuint32_t_val); + svtbl2(svfloat64x2_t_val, svuint64_t_val); + svtbl2(svint8x2_t_val, svuint8_t_val); + svtbl2(svint16x2_t_val, svuint16_t_val); + svtbl2(svint32x2_t_val, svuint32_t_val); + svtbl2(svint64x2_t_val, svuint64_t_val); + svtbl2(svuint8x2_t_val, svuint8_t_val); + svtbl2(svuint16x2_t_val, svuint16_t_val); + svtbl2(svuint32x2_t_val, svuint32_t_val); + svtbl2(svuint64x2_t_val, svuint64_t_val); + svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); + svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); + svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); + svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); + svtbl2_s8(svint8x2_t_val, svuint8_t_val); + svtbl2_s16(svint16x2_t_val, svuint16_t_val); + svtbl2_s32(svint32x2_t_val, svuint32_t_val); + svtbl2_s64(svint64x2_t_val, svuint64_t_val); + svtbl2_u8(svuint8x2_t_val, svuint8_t_val); + svtbl2_u16(svuint16x2_t_val, svuint16_t_val); + svtbl2_u32(svuint32x2_t_val, svuint32_t_val); + svtbl2_u64(svuint64x2_t_val, svuint64_t_val); + svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); + svwhilege_b8(int32_t_val, int32_t_val); + svwhilege_b8(int64_t_val, int64_t_val); + svwhilege_b8(uint32_t_val, uint32_t_val); + svwhilege_b8(uint64_t_val, uint64_t_val); + svwhilege_b8_s32(int32_t_val, int32_t_val); + svwhilege_b8_s64(int64_t_val, int64_t_val); + svwhilege_b8_u32(uint32_t_val, uint32_t_val); + svwhilege_b8_u64(uint64_t_val, uint64_t_val); + svwhilege_b16(int32_t_val, int32_t_val); + svwhilege_b16(int64_t_val, int64_t_val); + svwhilege_b16(uint32_t_val, uint32_t_val); + svwhilege_b16(uint64_t_val, uint64_t_val); + svwhilege_b16_s32(int32_t_val, int32_t_val); + svwhilege_b16_s64(int64_t_val, int64_t_val); + svwhilege_b16_u32(uint32_t_val, uint32_t_val); + svwhilege_b16_u64(uint64_t_val, uint64_t_val); + svwhilege_b32(int32_t_val, int32_t_val); + svwhilege_b32(int64_t_val, int64_t_val); + svwhilege_b32(uint32_t_val, uint32_t_val); + svwhilege_b32(uint64_t_val, uint64_t_val); + svwhilege_b32_s32(int32_t_val, int32_t_val); + svwhilege_b32_s64(int64_t_val, int64_t_val); + svwhilege_b32_u32(uint32_t_val, uint32_t_val); + svwhilege_b32_u64(uint64_t_val, uint64_t_val); + svwhilege_b64(int32_t_val, int32_t_val); + svwhilege_b64(int64_t_val, int64_t_val); + svwhilege_b64(uint32_t_val, uint32_t_val); + svwhilege_b64(uint64_t_val, uint64_t_val); + svwhilege_b64_s32(int32_t_val, int32_t_val); + svwhilege_b64_s64(int64_t_val, int64_t_val); + svwhilege_b64_u32(uint32_t_val, uint32_t_val); + svwhilege_b64_u64(uint64_t_val, uint64_t_val); + svwhilegt_b8(int32_t_val, int32_t_val); + svwhilegt_b8(int64_t_val, int64_t_val); + svwhilegt_b8(uint32_t_val, uint32_t_val); + svwhilegt_b8(uint64_t_val, uint64_t_val); + svwhilegt_b8_s32(int32_t_val, int32_t_val); + svwhilegt_b8_s64(int64_t_val, int64_t_val); + svwhilegt_b8_u32(uint32_t_val, uint32_t_val); + svwhilegt_b8_u64(uint64_t_val, uint64_t_val); + svwhilegt_b16(int32_t_val, int32_t_val); + svwhilegt_b16(int64_t_val, int64_t_val); + svwhilegt_b16(uint32_t_val, uint32_t_val); + svwhilegt_b16(uint64_t_val, uint64_t_val); + svwhilegt_b16_s32(int32_t_val, int32_t_val); + svwhilegt_b16_s64(int64_t_val, int64_t_val); + svwhilegt_b16_u32(uint32_t_val, uint32_t_val); + svwhilegt_b16_u64(uint64_t_val, uint64_t_val); + svwhilegt_b32(int32_t_val, int32_t_val); + svwhilegt_b32(int64_t_val, int64_t_val); + svwhilegt_b32(uint32_t_val, uint32_t_val); + svwhilegt_b32(uint64_t_val, uint64_t_val); + svwhilegt_b32_s32(int32_t_val, int32_t_val); + svwhilegt_b32_s64(int64_t_val, int64_t_val); + svwhilegt_b32_u32(uint32_t_val, uint32_t_val); + svwhilegt_b32_u64(uint64_t_val, uint64_t_val); + svwhilegt_b64(int32_t_val, int32_t_val); + svwhilegt_b64(int64_t_val, int64_t_val); + svwhilegt_b64(uint32_t_val, uint32_t_val); + svwhilegt_b64(uint64_t_val, uint64_t_val); + svwhilegt_b64_s32(int32_t_val, int32_t_val); + svwhilegt_b64_s64(int64_t_val, int64_t_val); + svwhilegt_b64_u32(uint32_t_val, uint32_t_val); + svwhilegt_b64_u64(uint64_t_val, uint64_t_val); + svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svxar(svint8_t_val, svint8_t_val, 2); + svxar(svint16_t_val, svint16_t_val, 2); + svxar(svint32_t_val, svint32_t_val, 2); + svxar(svint64_t_val, svint64_t_val, 2); + svxar(svuint8_t_val, svuint8_t_val, 2); + svxar(svuint16_t_val, svuint16_t_val, 2); + svxar(svuint32_t_val, svuint32_t_val, 2); + svxar(svuint64_t_val, svuint64_t_val, 2); + svxar_n_s8(svint8_t_val, svint8_t_val, 2); + svxar_n_s16(svint16_t_val, svint16_t_val, 2); + svxar_n_s32(svint32_t_val, svint32_t_val, 2); + svxar_n_s64(svint64_t_val, svint64_t_val, 2); + svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); + svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); + svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); + svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sve-sha3_AND_sme2p1.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sme2p1_AND_sve-sha3.c index 7e4a06f..8cc9271 100644 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sve-sha3_AND_sme2p1.c +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sme2p1_AND_sve-sha3.c @@ -7,7 +7,7 @@ #include <arm_sve.h> -// Properties: guard="sve,sve-sha3" streaming_guard="sme,sve-sha3,sme2p1" flags="feature-dependent" +// Properties: guard="sve,sve-sha3" streaming_guard="sme,sme2p1,sve-sha3" flags="feature-dependent" void test(void) { svint64_t svint64_t_val; diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c deleted file mode 100644 index b149f44..0000000 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c +++ /dev/null @@ -1,16470 +0,0 @@ -// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify=streaming-guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2 -verify -// expected-no-diagnostics - -// REQUIRES: aarch64-registered-target - -#include <arm_sve.h> - -// Properties: guard="sve,sve2" streaming_guard="sme" flags="feature-dependent" - -void test(void) { - bfloat16_t * bfloat16_t_ptr_val; - float16_t * float16_t_ptr_val; - float16_t float16_t_val; - float32_t * float32_t_ptr_val; - float64_t * float64_t_ptr_val; - int8_t * int8_t_ptr_val; - int8_t int8_t_val; - int16_t * int16_t_ptr_val; - int16_t int16_t_val; - int32_t * int32_t_ptr_val; - int32_t int32_t_val; - int64_t * int64_t_ptr_val; - int64_t int64_t_val; - svbfloat16_t svbfloat16_t_val; - svbfloat16x2_t svbfloat16x2_t_val; - svbool_t svbool_t_val; - svfloat16_t svfloat16_t_val; - svfloat16x2_t svfloat16x2_t_val; - svfloat32_t svfloat32_t_val; - svfloat32x2_t svfloat32x2_t_val; - svfloat64_t svfloat64_t_val; - svfloat64x2_t svfloat64x2_t_val; - svint8_t svint8_t_val; - svint8x2_t svint8x2_t_val; - svint16_t svint16_t_val; - svint16x2_t svint16x2_t_val; - svint32_t svint32_t_val; - svint32x2_t svint32x2_t_val; - svint64_t svint64_t_val; - svint64x2_t svint64x2_t_val; - svuint8_t svuint8_t_val; - svuint8x2_t svuint8x2_t_val; - svuint16_t svuint16_t_val; - svuint16x2_t svuint16x2_t_val; - svuint32_t svuint32_t_val; - svuint32x2_t svuint32x2_t_val; - svuint64_t svuint64_t_val; - svuint64x2_t svuint64x2_t_val; - uint8_t * uint8_t_ptr_val; - uint8_t uint8_t_val; - uint16_t * uint16_t_ptr_val; - uint16_t uint16_t_val; - uint32_t * uint32_t_ptr_val; - uint32_t uint32_t_val; - uint64_t * uint64_t_ptr_val; - uint64_t uint64_t_val; - - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s8(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s16(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s32(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s64(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u8(svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u16(svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u32(svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u64(svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f16_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f16_z(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f32_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f32_z(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f64_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f64_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_z(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_z(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_s16(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_s32(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_s64(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_u16(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_u32(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_u64(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_s16(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_s32(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_s64(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_u16(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_u32(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_u64(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_s16(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_s32(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_s64(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul_n_u8(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul_u8(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s8_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s8_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s16_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s16_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s32_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s32_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s64_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s64_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s8(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s16(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s32(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s64(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s8(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s8(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s8_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s8_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s16_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s16_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s32_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s32_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s64_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s64_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s8(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s8(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_s16(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_s32(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_s64(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_u16(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_u32(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_u64(svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svuint8_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svuint16_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svuint32_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_s16(svint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_s32(svint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_s64(svint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_u16(svuint8_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_u32(svuint16_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_u64(svuint32_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb_s16(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb_s32(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb_s64(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt(svuint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt(svuint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt(svuint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt_s16(svuint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt_s32(svuint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt_s64(svuint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_u32_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_u32_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_u32_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_u32_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_s16(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_s32(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_s64(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_u16(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_u32(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_u64(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_s16(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_s32(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_s64(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_u16(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_u32(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_u64(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svbfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svfloat32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svfloat64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s8(svint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s16(svint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s32(svint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s64(svint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u8(svuint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u16(svuint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u32(svuint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u64(svuint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); -} - -void test_streaming(void) __arm_streaming{ - bfloat16_t * bfloat16_t_ptr_val; - float16_t * float16_t_ptr_val; - float16_t float16_t_val; - float32_t * float32_t_ptr_val; - float64_t * float64_t_ptr_val; - int8_t * int8_t_ptr_val; - int8_t int8_t_val; - int16_t * int16_t_ptr_val; - int16_t int16_t_val; - int32_t * int32_t_ptr_val; - int32_t int32_t_val; - int64_t * int64_t_ptr_val; - int64_t int64_t_val; - svbfloat16_t svbfloat16_t_val; - svbfloat16x2_t svbfloat16x2_t_val; - svbool_t svbool_t_val; - svfloat16_t svfloat16_t_val; - svfloat16x2_t svfloat16x2_t_val; - svfloat32_t svfloat32_t_val; - svfloat32x2_t svfloat32x2_t_val; - svfloat64_t svfloat64_t_val; - svfloat64x2_t svfloat64x2_t_val; - svint8_t svint8_t_val; - svint8x2_t svint8x2_t_val; - svint16_t svint16_t_val; - svint16x2_t svint16x2_t_val; - svint32_t svint32_t_val; - svint32x2_t svint32x2_t_val; - svint64_t svint64_t_val; - svint64x2_t svint64x2_t_val; - svuint8_t svuint8_t_val; - svuint8x2_t svuint8x2_t_val; - svuint16_t svuint16_t_val; - svuint16x2_t svuint16x2_t_val; - svuint32_t svuint32_t_val; - svuint32x2_t svuint32x2_t_val; - svuint64_t svuint64_t_val; - svuint64x2_t svuint64x2_t_val; - uint8_t * uint8_t_ptr_val; - uint8_t uint8_t_val; - uint16_t * uint16_t_ptr_val; - uint16_t uint16_t_val; - uint32_t * uint32_t_ptr_val; - uint32_t uint32_t_val; - uint64_t * uint64_t_ptr_val; - uint64_t uint64_t_val; - - svaba(svint8_t_val, svint8_t_val, int8_t_val); - svaba(svint8_t_val, svint8_t_val, svint8_t_val); - svaba(svint16_t_val, svint16_t_val, int16_t_val); - svaba(svint16_t_val, svint16_t_val, svint16_t_val); - svaba(svint32_t_val, svint32_t_val, int32_t_val); - svaba(svint32_t_val, svint32_t_val, svint32_t_val); - svaba(svint64_t_val, svint64_t_val, int64_t_val); - svaba(svint64_t_val, svint64_t_val, svint64_t_val); - svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); - svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); - svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); - svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); - svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svabalb(svint16_t_val, svint8_t_val, int8_t_val); - svabalb(svint16_t_val, svint8_t_val, svint8_t_val); - svabalb(svint32_t_val, svint16_t_val, int16_t_val); - svabalb(svint32_t_val, svint16_t_val, svint16_t_val); - svabalb(svint64_t_val, svint32_t_val, int32_t_val); - svabalb(svint64_t_val, svint32_t_val, svint32_t_val); - svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); - svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); - svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); - svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svabalt(svint16_t_val, svint8_t_val, int8_t_val); - svabalt(svint16_t_val, svint8_t_val, svint8_t_val); - svabalt(svint32_t_val, svint16_t_val, int16_t_val); - svabalt(svint32_t_val, svint16_t_val, svint16_t_val); - svabalt(svint64_t_val, svint32_t_val, int32_t_val); - svabalt(svint64_t_val, svint32_t_val, svint32_t_val); - svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); - svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); - svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); - svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svabdlb(svint8_t_val, int8_t_val); - svabdlb(svint8_t_val, svint8_t_val); - svabdlb(svint16_t_val, int16_t_val); - svabdlb(svint16_t_val, svint16_t_val); - svabdlb(svint32_t_val, int32_t_val); - svabdlb(svint32_t_val, svint32_t_val); - svabdlb(svuint8_t_val, svuint8_t_val); - svabdlb(svuint8_t_val, uint8_t_val); - svabdlb(svuint16_t_val, svuint16_t_val); - svabdlb(svuint16_t_val, uint16_t_val); - svabdlb(svuint32_t_val, svuint32_t_val); - svabdlb(svuint32_t_val, uint32_t_val); - svabdlb_n_s16(svint8_t_val, int8_t_val); - svabdlb_n_s32(svint16_t_val, int16_t_val); - svabdlb_n_s64(svint32_t_val, int32_t_val); - svabdlb_n_u16(svuint8_t_val, uint8_t_val); - svabdlb_n_u32(svuint16_t_val, uint16_t_val); - svabdlb_n_u64(svuint32_t_val, uint32_t_val); - svabdlb_s16(svint8_t_val, svint8_t_val); - svabdlb_s32(svint16_t_val, svint16_t_val); - svabdlb_s64(svint32_t_val, svint32_t_val); - svabdlb_u16(svuint8_t_val, svuint8_t_val); - svabdlb_u32(svuint16_t_val, svuint16_t_val); - svabdlb_u64(svuint32_t_val, svuint32_t_val); - svabdlt(svint8_t_val, int8_t_val); - svabdlt(svint8_t_val, svint8_t_val); - svabdlt(svint16_t_val, int16_t_val); - svabdlt(svint16_t_val, svint16_t_val); - svabdlt(svint32_t_val, int32_t_val); - svabdlt(svint32_t_val, svint32_t_val); - svabdlt(svuint8_t_val, svuint8_t_val); - svabdlt(svuint8_t_val, uint8_t_val); - svabdlt(svuint16_t_val, svuint16_t_val); - svabdlt(svuint16_t_val, uint16_t_val); - svabdlt(svuint32_t_val, svuint32_t_val); - svabdlt(svuint32_t_val, uint32_t_val); - svabdlt_n_s16(svint8_t_val, int8_t_val); - svabdlt_n_s32(svint16_t_val, int16_t_val); - svabdlt_n_s64(svint32_t_val, int32_t_val); - svabdlt_n_u16(svuint8_t_val, uint8_t_val); - svabdlt_n_u32(svuint16_t_val, uint16_t_val); - svabdlt_n_u64(svuint32_t_val, uint32_t_val); - svabdlt_s16(svint8_t_val, svint8_t_val); - svabdlt_s32(svint16_t_val, svint16_t_val); - svabdlt_s64(svint32_t_val, svint32_t_val); - svabdlt_u16(svuint8_t_val, svuint8_t_val); - svabdlt_u32(svuint16_t_val, svuint16_t_val); - svabdlt_u64(svuint32_t_val, svuint32_t_val); - svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); - svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); - svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); - svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); - svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); - svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); - svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); - svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); - svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); - svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); - svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); - svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); - svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); - svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); - svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); - svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); - svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); - svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); - svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); - svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); - svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); - svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); - svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); - svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); - svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); - svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); - svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); - svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); - svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); - svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); - svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); - svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); - svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); - svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); - svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); - svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); - svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); - svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); - svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); - svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); - svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svaddhnb(svint16_t_val, int16_t_val); - svaddhnb(svint16_t_val, svint16_t_val); - svaddhnb(svint32_t_val, int32_t_val); - svaddhnb(svint32_t_val, svint32_t_val); - svaddhnb(svint64_t_val, int64_t_val); - svaddhnb(svint64_t_val, svint64_t_val); - svaddhnb(svuint16_t_val, svuint16_t_val); - svaddhnb(svuint16_t_val, uint16_t_val); - svaddhnb(svuint32_t_val, svuint32_t_val); - svaddhnb(svuint32_t_val, uint32_t_val); - svaddhnb(svuint64_t_val, svuint64_t_val); - svaddhnb(svuint64_t_val, uint64_t_val); - svaddhnb_n_s16(svint16_t_val, int16_t_val); - svaddhnb_n_s32(svint32_t_val, int32_t_val); - svaddhnb_n_s64(svint64_t_val, int64_t_val); - svaddhnb_n_u16(svuint16_t_val, uint16_t_val); - svaddhnb_n_u32(svuint32_t_val, uint32_t_val); - svaddhnb_n_u64(svuint64_t_val, uint64_t_val); - svaddhnb_s16(svint16_t_val, svint16_t_val); - svaddhnb_s32(svint32_t_val, svint32_t_val); - svaddhnb_s64(svint64_t_val, svint64_t_val); - svaddhnb_u16(svuint16_t_val, svuint16_t_val); - svaddhnb_u32(svuint32_t_val, svuint32_t_val); - svaddhnb_u64(svuint64_t_val, svuint64_t_val); - svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); - svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); - svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); - svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); - svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); - svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); - svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svaddlb(svint8_t_val, int8_t_val); - svaddlb(svint8_t_val, svint8_t_val); - svaddlb(svint16_t_val, int16_t_val); - svaddlb(svint16_t_val, svint16_t_val); - svaddlb(svint32_t_val, int32_t_val); - svaddlb(svint32_t_val, svint32_t_val); - svaddlb(svuint8_t_val, svuint8_t_val); - svaddlb(svuint8_t_val, uint8_t_val); - svaddlb(svuint16_t_val, svuint16_t_val); - svaddlb(svuint16_t_val, uint16_t_val); - svaddlb(svuint32_t_val, svuint32_t_val); - svaddlb(svuint32_t_val, uint32_t_val); - svaddlb_n_s16(svint8_t_val, int8_t_val); - svaddlb_n_s32(svint16_t_val, int16_t_val); - svaddlb_n_s64(svint32_t_val, int32_t_val); - svaddlb_n_u16(svuint8_t_val, uint8_t_val); - svaddlb_n_u32(svuint16_t_val, uint16_t_val); - svaddlb_n_u64(svuint32_t_val, uint32_t_val); - svaddlb_s16(svint8_t_val, svint8_t_val); - svaddlb_s32(svint16_t_val, svint16_t_val); - svaddlb_s64(svint32_t_val, svint32_t_val); - svaddlb_u16(svuint8_t_val, svuint8_t_val); - svaddlb_u32(svuint16_t_val, svuint16_t_val); - svaddlb_u64(svuint32_t_val, svuint32_t_val); - svaddlbt(svint8_t_val, int8_t_val); - svaddlbt(svint8_t_val, svint8_t_val); - svaddlbt(svint16_t_val, int16_t_val); - svaddlbt(svint16_t_val, svint16_t_val); - svaddlbt(svint32_t_val, int32_t_val); - svaddlbt(svint32_t_val, svint32_t_val); - svaddlbt_n_s16(svint8_t_val, int8_t_val); - svaddlbt_n_s32(svint16_t_val, int16_t_val); - svaddlbt_n_s64(svint32_t_val, int32_t_val); - svaddlbt_s16(svint8_t_val, svint8_t_val); - svaddlbt_s32(svint16_t_val, svint16_t_val); - svaddlbt_s64(svint32_t_val, svint32_t_val); - svaddlt(svint8_t_val, int8_t_val); - svaddlt(svint8_t_val, svint8_t_val); - svaddlt(svint16_t_val, int16_t_val); - svaddlt(svint16_t_val, svint16_t_val); - svaddlt(svint32_t_val, int32_t_val); - svaddlt(svint32_t_val, svint32_t_val); - svaddlt(svuint8_t_val, svuint8_t_val); - svaddlt(svuint8_t_val, uint8_t_val); - svaddlt(svuint16_t_val, svuint16_t_val); - svaddlt(svuint16_t_val, uint16_t_val); - svaddlt(svuint32_t_val, svuint32_t_val); - svaddlt(svuint32_t_val, uint32_t_val); - svaddlt_n_s16(svint8_t_val, int8_t_val); - svaddlt_n_s32(svint16_t_val, int16_t_val); - svaddlt_n_s64(svint32_t_val, int32_t_val); - svaddlt_n_u16(svuint8_t_val, uint8_t_val); - svaddlt_n_u32(svuint16_t_val, uint16_t_val); - svaddlt_n_u64(svuint32_t_val, uint32_t_val); - svaddlt_s16(svint8_t_val, svint8_t_val); - svaddlt_s32(svint16_t_val, svint16_t_val); - svaddlt_s64(svint32_t_val, svint32_t_val); - svaddlt_u16(svuint8_t_val, svuint8_t_val); - svaddlt_u32(svuint16_t_val, svuint16_t_val); - svaddlt_u64(svuint32_t_val, svuint32_t_val); - svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); - svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); - svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); - svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); - svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); - svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); - svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); - svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); - svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svaddwb(svint16_t_val, int8_t_val); - svaddwb(svint16_t_val, svint8_t_val); - svaddwb(svint32_t_val, int16_t_val); - svaddwb(svint32_t_val, svint16_t_val); - svaddwb(svint64_t_val, int32_t_val); - svaddwb(svint64_t_val, svint32_t_val); - svaddwb(svuint16_t_val, svuint8_t_val); - svaddwb(svuint16_t_val, uint8_t_val); - svaddwb(svuint32_t_val, svuint16_t_val); - svaddwb(svuint32_t_val, uint16_t_val); - svaddwb(svuint64_t_val, svuint32_t_val); - svaddwb(svuint64_t_val, uint32_t_val); - svaddwb_n_s16(svint16_t_val, int8_t_val); - svaddwb_n_s32(svint32_t_val, int16_t_val); - svaddwb_n_s64(svint64_t_val, int32_t_val); - svaddwb_n_u16(svuint16_t_val, uint8_t_val); - svaddwb_n_u32(svuint32_t_val, uint16_t_val); - svaddwb_n_u64(svuint64_t_val, uint32_t_val); - svaddwb_s16(svint16_t_val, svint8_t_val); - svaddwb_s32(svint32_t_val, svint16_t_val); - svaddwb_s64(svint64_t_val, svint32_t_val); - svaddwb_u16(svuint16_t_val, svuint8_t_val); - svaddwb_u32(svuint32_t_val, svuint16_t_val); - svaddwb_u64(svuint64_t_val, svuint32_t_val); - svaddwt(svint16_t_val, int8_t_val); - svaddwt(svint16_t_val, svint8_t_val); - svaddwt(svint32_t_val, int16_t_val); - svaddwt(svint32_t_val, svint16_t_val); - svaddwt(svint64_t_val, int32_t_val); - svaddwt(svint64_t_val, svint32_t_val); - svaddwt(svuint16_t_val, svuint8_t_val); - svaddwt(svuint16_t_val, uint8_t_val); - svaddwt(svuint32_t_val, svuint16_t_val); - svaddwt(svuint32_t_val, uint16_t_val); - svaddwt(svuint64_t_val, svuint32_t_val); - svaddwt(svuint64_t_val, uint32_t_val); - svaddwt_n_s16(svint16_t_val, int8_t_val); - svaddwt_n_s32(svint32_t_val, int16_t_val); - svaddwt_n_s64(svint64_t_val, int32_t_val); - svaddwt_n_u16(svuint16_t_val, uint8_t_val); - svaddwt_n_u32(svuint32_t_val, uint16_t_val); - svaddwt_n_u64(svuint64_t_val, uint32_t_val); - svaddwt_s16(svint16_t_val, svint8_t_val); - svaddwt_s32(svint32_t_val, svint16_t_val); - svaddwt_s64(svint64_t_val, svint32_t_val); - svaddwt_u16(svuint16_t_val, svuint8_t_val); - svaddwt_u32(svuint32_t_val, svuint16_t_val); - svaddwt_u64(svuint64_t_val, svuint32_t_val); - svbcax(svint8_t_val, svint8_t_val, int8_t_val); - svbcax(svint8_t_val, svint8_t_val, svint8_t_val); - svbcax(svint16_t_val, svint16_t_val, int16_t_val); - svbcax(svint16_t_val, svint16_t_val, svint16_t_val); - svbcax(svint32_t_val, svint32_t_val, int32_t_val); - svbcax(svint32_t_val, svint32_t_val, svint32_t_val); - svbcax(svint64_t_val, svint64_t_val, int64_t_val); - svbcax(svint64_t_val, svint64_t_val, svint64_t_val); - svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); - svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); - svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); - svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); - svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); - svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); - svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); - svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); - svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); - svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); - svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); - svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); - svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); - svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); - svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); - svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); - svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbsl(svint8_t_val, svint8_t_val, int8_t_val); - svbsl(svint8_t_val, svint8_t_val, svint8_t_val); - svbsl(svint16_t_val, svint16_t_val, int16_t_val); - svbsl(svint16_t_val, svint16_t_val, svint16_t_val); - svbsl(svint32_t_val, svint32_t_val, int32_t_val); - svbsl(svint32_t_val, svint32_t_val, svint32_t_val); - svbsl(svint64_t_val, svint64_t_val, int64_t_val); - svbsl(svint64_t_val, svint64_t_val, svint64_t_val); - svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svcadd(svint8_t_val, svint8_t_val, 90); - svcadd(svint16_t_val, svint16_t_val, 90); - svcadd(svint32_t_val, svint32_t_val, 90); - svcadd(svint64_t_val, svint64_t_val, 90); - svcadd(svuint8_t_val, svuint8_t_val, 90); - svcadd(svuint16_t_val, svuint16_t_val, 90); - svcadd(svuint32_t_val, svuint32_t_val, 90); - svcadd(svuint64_t_val, svuint64_t_val, 90); - svcadd_s8(svint8_t_val, svint8_t_val, 90); - svcadd_s16(svint16_t_val, svint16_t_val, 90); - svcadd_s32(svint32_t_val, svint32_t_val, 90); - svcadd_s64(svint64_t_val, svint64_t_val, 90); - svcadd_u8(svuint8_t_val, svuint8_t_val, 90); - svcadd_u16(svuint16_t_val, svuint16_t_val, 90); - svcadd_u32(svuint32_t_val, svuint32_t_val, 90); - svcadd_u64(svuint64_t_val, svuint64_t_val, 90); - svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); - svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); - svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); - svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); - svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); - svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); - svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); - svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); - svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); - svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); - svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); - svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); - svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); - svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); - svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); - svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); - svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); - svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); - svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); - svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); - svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); - svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); - svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); - svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); - svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); - svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); - svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); - svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); - svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); - svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); - svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); - svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); - svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); - svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); - svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); - svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); - svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); - svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); - svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); - svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); - svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - svcvtx_f32_x(svbool_t_val, svfloat64_t_val); - svcvtx_f32_z(svbool_t_val, svfloat64_t_val); - svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - sveor3(svint8_t_val, svint8_t_val, int8_t_val); - sveor3(svint8_t_val, svint8_t_val, svint8_t_val); - sveor3(svint16_t_val, svint16_t_val, int16_t_val); - sveor3(svint16_t_val, svint16_t_val, svint16_t_val); - sveor3(svint32_t_val, svint32_t_val, int32_t_val); - sveor3(svint32_t_val, svint32_t_val, svint32_t_val); - sveor3(svint64_t_val, svint64_t_val, int64_t_val); - sveor3(svint64_t_val, svint64_t_val, svint64_t_val); - sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); - sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); - sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); - sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); - sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); - sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); - sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); - sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); - sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); - sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); - sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); - sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); - sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - sveorbt(svint8_t_val, svint8_t_val, int8_t_val); - sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); - sveorbt(svint16_t_val, svint16_t_val, int16_t_val); - sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); - sveorbt(svint32_t_val, svint32_t_val, int32_t_val); - sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); - sveorbt(svint64_t_val, svint64_t_val, int64_t_val); - sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); - sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); - sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); - sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); - sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); - sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); - sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); - sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); - sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); - sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); - sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); - sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - sveortb(svint8_t_val, svint8_t_val, int8_t_val); - sveortb(svint8_t_val, svint8_t_val, svint8_t_val); - sveortb(svint16_t_val, svint16_t_val, int16_t_val); - sveortb(svint16_t_val, svint16_t_val, svint16_t_val); - sveortb(svint32_t_val, svint32_t_val, int32_t_val); - sveortb(svint32_t_val, svint32_t_val, svint32_t_val); - sveortb(svint64_t_val, svint64_t_val, int64_t_val); - sveortb(svint64_t_val, svint64_t_val, svint64_t_val); - sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); - sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); - sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); - sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); - sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); - sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); - sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); - sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); - sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); - sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); - sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); - svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); - svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); - svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); - svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); - svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); - svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); - svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); - svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); - svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); - svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); - svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); - svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); - svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); - svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); - svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); - svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); - svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); - svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); - svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); - svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); - svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); - svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); - svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); - svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); - svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); - svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); - svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); - svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); - svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); - svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); - svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); - svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); - svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); - svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); - svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); - svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); - svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); - svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); - svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); - svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); - svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); - svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); - svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); - svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); - svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); - svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); - svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); - svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); - svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); - svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); - svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); - svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); - svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); - svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); - svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); - svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); - svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); - svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); - svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); - svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); - svlogb_f16_x(svbool_t_val, svfloat16_t_val); - svlogb_f16_z(svbool_t_val, svfloat16_t_val); - svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); - svlogb_f32_x(svbool_t_val, svfloat32_t_val); - svlogb_f32_z(svbool_t_val, svfloat32_t_val); - svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); - svlogb_f64_x(svbool_t_val, svfloat64_t_val); - svlogb_f64_z(svbool_t_val, svfloat64_t_val); - svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); - svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); - svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); - svlogb_x(svbool_t_val, svfloat16_t_val); - svlogb_x(svbool_t_val, svfloat32_t_val); - svlogb_x(svbool_t_val, svfloat64_t_val); - svlogb_z(svbool_t_val, svfloat16_t_val); - svlogb_z(svbool_t_val, svfloat32_t_val); - svlogb_z(svbool_t_val, svfloat64_t_val); - svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); - svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); - svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); - svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); - svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); - svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); - svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); - svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); - svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); - svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); - svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); - svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); - svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); - svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); - svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); - svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); - svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlalb(svint16_t_val, svint8_t_val, int8_t_val); - svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); - svmlalb(svint32_t_val, svint16_t_val, int16_t_val); - svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); - svmlalb(svint64_t_val, svint32_t_val, int32_t_val); - svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); - svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlalt(svint16_t_val, svint8_t_val, int8_t_val); - svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); - svmlalt(svint32_t_val, svint16_t_val, int16_t_val); - svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); - svmlalt(svint64_t_val, svint32_t_val, int32_t_val); - svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); - svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlslb(svint16_t_val, svint8_t_val, int8_t_val); - svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); - svmlslb(svint32_t_val, svint16_t_val, int16_t_val); - svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); - svmlslb(svint64_t_val, svint32_t_val, int32_t_val); - svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); - svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlslt(svint16_t_val, svint8_t_val, int8_t_val); - svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); - svmlslt(svint32_t_val, svint16_t_val, int16_t_val); - svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); - svmlslt(svint64_t_val, svint32_t_val, int32_t_val); - svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); - svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - svmovlb(svint8_t_val); - svmovlb(svint16_t_val); - svmovlb(svint32_t_val); - svmovlb(svuint8_t_val); - svmovlb(svuint16_t_val); - svmovlb(svuint32_t_val); - svmovlb_s16(svint8_t_val); - svmovlb_s32(svint16_t_val); - svmovlb_s64(svint32_t_val); - svmovlb_u16(svuint8_t_val); - svmovlb_u32(svuint16_t_val); - svmovlb_u64(svuint32_t_val); - svmovlt(svint8_t_val); - svmovlt(svint16_t_val); - svmovlt(svint32_t_val); - svmovlt(svuint8_t_val); - svmovlt(svuint16_t_val); - svmovlt(svuint32_t_val); - svmovlt_s16(svint8_t_val); - svmovlt_s32(svint16_t_val); - svmovlt_s64(svint32_t_val); - svmovlt_u16(svuint8_t_val); - svmovlt_u32(svuint16_t_val); - svmovlt_u64(svuint32_t_val); - svmul_lane(svint16_t_val, svint16_t_val, 1); - svmul_lane(svint32_t_val, svint32_t_val, 1); - svmul_lane(svint64_t_val, svint64_t_val, 1); - svmul_lane(svuint16_t_val, svuint16_t_val, 1); - svmul_lane(svuint32_t_val, svuint32_t_val, 1); - svmul_lane(svuint64_t_val, svuint64_t_val, 1); - svmul_lane_s16(svint16_t_val, svint16_t_val, 1); - svmul_lane_s32(svint32_t_val, svint32_t_val, 1); - svmul_lane_s64(svint64_t_val, svint64_t_val, 1); - svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); - svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); - svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); - svmullb(svint8_t_val, int8_t_val); - svmullb(svint8_t_val, svint8_t_val); - svmullb(svint16_t_val, int16_t_val); - svmullb(svint16_t_val, svint16_t_val); - svmullb(svint32_t_val, int32_t_val); - svmullb(svint32_t_val, svint32_t_val); - svmullb(svuint8_t_val, svuint8_t_val); - svmullb(svuint8_t_val, uint8_t_val); - svmullb(svuint16_t_val, svuint16_t_val); - svmullb(svuint16_t_val, uint16_t_val); - svmullb(svuint32_t_val, svuint32_t_val); - svmullb(svuint32_t_val, uint32_t_val); - svmullb_lane(svint16_t_val, svint16_t_val, 1); - svmullb_lane(svint32_t_val, svint32_t_val, 1); - svmullb_lane(svuint16_t_val, svuint16_t_val, 1); - svmullb_lane(svuint32_t_val, svuint32_t_val, 1); - svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); - svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); - svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); - svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); - svmullb_n_s16(svint8_t_val, int8_t_val); - svmullb_n_s32(svint16_t_val, int16_t_val); - svmullb_n_s64(svint32_t_val, int32_t_val); - svmullb_n_u16(svuint8_t_val, uint8_t_val); - svmullb_n_u32(svuint16_t_val, uint16_t_val); - svmullb_n_u64(svuint32_t_val, uint32_t_val); - svmullb_s16(svint8_t_val, svint8_t_val); - svmullb_s32(svint16_t_val, svint16_t_val); - svmullb_s64(svint32_t_val, svint32_t_val); - svmullb_u16(svuint8_t_val, svuint8_t_val); - svmullb_u32(svuint16_t_val, svuint16_t_val); - svmullb_u64(svuint32_t_val, svuint32_t_val); - svmullt(svint8_t_val, int8_t_val); - svmullt(svint8_t_val, svint8_t_val); - svmullt(svint16_t_val, int16_t_val); - svmullt(svint16_t_val, svint16_t_val); - svmullt(svint32_t_val, int32_t_val); - svmullt(svint32_t_val, svint32_t_val); - svmullt(svuint8_t_val, svuint8_t_val); - svmullt(svuint8_t_val, uint8_t_val); - svmullt(svuint16_t_val, svuint16_t_val); - svmullt(svuint16_t_val, uint16_t_val); - svmullt(svuint32_t_val, svuint32_t_val); - svmullt(svuint32_t_val, uint32_t_val); - svmullt_lane(svint16_t_val, svint16_t_val, 1); - svmullt_lane(svint32_t_val, svint32_t_val, 1); - svmullt_lane(svuint16_t_val, svuint16_t_val, 1); - svmullt_lane(svuint32_t_val, svuint32_t_val, 1); - svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); - svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); - svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); - svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); - svmullt_n_s16(svint8_t_val, int8_t_val); - svmullt_n_s32(svint16_t_val, int16_t_val); - svmullt_n_s64(svint32_t_val, int32_t_val); - svmullt_n_u16(svuint8_t_val, uint8_t_val); - svmullt_n_u32(svuint16_t_val, uint16_t_val); - svmullt_n_u64(svuint32_t_val, uint32_t_val); - svmullt_s16(svint8_t_val, svint8_t_val); - svmullt_s32(svint16_t_val, svint16_t_val); - svmullt_s64(svint32_t_val, svint32_t_val); - svmullt_u16(svuint8_t_val, svuint8_t_val); - svmullt_u32(svuint16_t_val, svuint16_t_val); - svmullt_u64(svuint32_t_val, svuint32_t_val); - svnbsl(svint8_t_val, svint8_t_val, int8_t_val); - svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); - svnbsl(svint16_t_val, svint16_t_val, int16_t_val); - svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); - svnbsl(svint32_t_val, svint32_t_val, int32_t_val); - svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); - svnbsl(svint64_t_val, svint64_t_val, int64_t_val); - svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); - svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); - svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); - svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); - svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); - svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svpmul(svuint8_t_val, svuint8_t_val); - svpmul(svuint8_t_val, uint8_t_val); - svpmul_n_u8(svuint8_t_val, uint8_t_val); - svpmul_u8(svuint8_t_val, svuint8_t_val); - svpmullb(svuint8_t_val, svuint8_t_val); - svpmullb(svuint8_t_val, uint8_t_val); - svpmullb(svuint32_t_val, svuint32_t_val); - svpmullb(svuint32_t_val, uint32_t_val); - svpmullb_n_u16(svuint8_t_val, uint8_t_val); - svpmullb_n_u64(svuint32_t_val, uint32_t_val); - svpmullb_pair(svuint8_t_val, svuint8_t_val); - svpmullb_pair(svuint8_t_val, uint8_t_val); - svpmullb_pair(svuint32_t_val, svuint32_t_val); - svpmullb_pair(svuint32_t_val, uint32_t_val); - svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); - svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); - svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); - svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); - svpmullb_u16(svuint8_t_val, svuint8_t_val); - svpmullb_u64(svuint32_t_val, svuint32_t_val); - svpmullt(svuint8_t_val, svuint8_t_val); - svpmullt(svuint8_t_val, uint8_t_val); - svpmullt(svuint32_t_val, svuint32_t_val); - svpmullt(svuint32_t_val, uint32_t_val); - svpmullt_n_u16(svuint8_t_val, uint8_t_val); - svpmullt_n_u64(svuint32_t_val, uint32_t_val); - svpmullt_pair(svuint8_t_val, svuint8_t_val); - svpmullt_pair(svuint8_t_val, uint8_t_val); - svpmullt_pair(svuint32_t_val, svuint32_t_val); - svpmullt_pair(svuint32_t_val, uint32_t_val); - svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); - svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); - svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); - svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); - svpmullt_u16(svuint8_t_val, svuint8_t_val); - svpmullt_u64(svuint32_t_val, svuint32_t_val); - svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); - svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); - svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); - svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); - svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); - svqabs_s8_x(svbool_t_val, svint8_t_val); - svqabs_s8_z(svbool_t_val, svint8_t_val); - svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); - svqabs_s16_x(svbool_t_val, svint16_t_val); - svqabs_s16_z(svbool_t_val, svint16_t_val); - svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); - svqabs_s32_x(svbool_t_val, svint32_t_val); - svqabs_s32_z(svbool_t_val, svint32_t_val); - svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); - svqabs_s64_x(svbool_t_val, svint64_t_val); - svqabs_s64_z(svbool_t_val, svint64_t_val); - svqabs_x(svbool_t_val, svint8_t_val); - svqabs_x(svbool_t_val, svint16_t_val); - svqabs_x(svbool_t_val, svint32_t_val); - svqabs_x(svbool_t_val, svint64_t_val); - svqabs_z(svbool_t_val, svint8_t_val); - svqabs_z(svbool_t_val, svint16_t_val); - svqabs_z(svbool_t_val, svint32_t_val); - svqabs_z(svbool_t_val, svint64_t_val); - svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); - svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); - svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); - svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); - svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); - svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); - svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); - svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); - svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); - svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); - svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); - svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); - svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svqcadd(svint8_t_val, svint8_t_val, 90); - svqcadd(svint16_t_val, svint16_t_val, 90); - svqcadd(svint32_t_val, svint32_t_val, 90); - svqcadd(svint64_t_val, svint64_t_val, 90); - svqcadd_s8(svint8_t_val, svint8_t_val, 90); - svqcadd_s16(svint16_t_val, svint16_t_val, 90); - svqcadd_s32(svint32_t_val, svint32_t_val, 90); - svqcadd_s64(svint64_t_val, svint64_t_val, 90); - svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - svqdmulh(svint8_t_val, int8_t_val); - svqdmulh(svint8_t_val, svint8_t_val); - svqdmulh(svint16_t_val, int16_t_val); - svqdmulh(svint16_t_val, svint16_t_val); - svqdmulh(svint32_t_val, int32_t_val); - svqdmulh(svint32_t_val, svint32_t_val); - svqdmulh(svint64_t_val, int64_t_val); - svqdmulh(svint64_t_val, svint64_t_val); - svqdmulh_lane(svint16_t_val, svint16_t_val, 1); - svqdmulh_lane(svint32_t_val, svint32_t_val, 1); - svqdmulh_lane(svint64_t_val, svint64_t_val, 1); - svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); - svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); - svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); - svqdmulh_n_s8(svint8_t_val, int8_t_val); - svqdmulh_n_s16(svint16_t_val, int16_t_val); - svqdmulh_n_s32(svint32_t_val, int32_t_val); - svqdmulh_n_s64(svint64_t_val, int64_t_val); - svqdmulh_s8(svint8_t_val, svint8_t_val); - svqdmulh_s16(svint16_t_val, svint16_t_val); - svqdmulh_s32(svint32_t_val, svint32_t_val); - svqdmulh_s64(svint64_t_val, svint64_t_val); - svqdmullb(svint8_t_val, int8_t_val); - svqdmullb(svint8_t_val, svint8_t_val); - svqdmullb(svint16_t_val, int16_t_val); - svqdmullb(svint16_t_val, svint16_t_val); - svqdmullb(svint32_t_val, int32_t_val); - svqdmullb(svint32_t_val, svint32_t_val); - svqdmullb_lane(svint16_t_val, svint16_t_val, 1); - svqdmullb_lane(svint32_t_val, svint32_t_val, 1); - svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); - svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); - svqdmullb_n_s16(svint8_t_val, int8_t_val); - svqdmullb_n_s32(svint16_t_val, int16_t_val); - svqdmullb_n_s64(svint32_t_val, int32_t_val); - svqdmullb_s16(svint8_t_val, svint8_t_val); - svqdmullb_s32(svint16_t_val, svint16_t_val); - svqdmullb_s64(svint32_t_val, svint32_t_val); - svqdmullt(svint8_t_val, int8_t_val); - svqdmullt(svint8_t_val, svint8_t_val); - svqdmullt(svint16_t_val, int16_t_val); - svqdmullt(svint16_t_val, svint16_t_val); - svqdmullt(svint32_t_val, int32_t_val); - svqdmullt(svint32_t_val, svint32_t_val); - svqdmullt_lane(svint16_t_val, svint16_t_val, 1); - svqdmullt_lane(svint32_t_val, svint32_t_val, 1); - svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); - svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); - svqdmullt_n_s16(svint8_t_val, int8_t_val); - svqdmullt_n_s32(svint16_t_val, int16_t_val); - svqdmullt_n_s64(svint32_t_val, int32_t_val); - svqdmullt_s16(svint8_t_val, svint8_t_val); - svqdmullt_s32(svint16_t_val, svint16_t_val); - svqdmullt_s64(svint32_t_val, svint32_t_val); - svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); - svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); - svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); - svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); - svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); - svqneg_s8_x(svbool_t_val, svint8_t_val); - svqneg_s8_z(svbool_t_val, svint8_t_val); - svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); - svqneg_s16_x(svbool_t_val, svint16_t_val); - svqneg_s16_z(svbool_t_val, svint16_t_val); - svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); - svqneg_s32_x(svbool_t_val, svint32_t_val); - svqneg_s32_z(svbool_t_val, svint32_t_val); - svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); - svqneg_s64_x(svbool_t_val, svint64_t_val); - svqneg_s64_z(svbool_t_val, svint64_t_val); - svqneg_x(svbool_t_val, svint8_t_val); - svqneg_x(svbool_t_val, svint16_t_val); - svqneg_x(svbool_t_val, svint32_t_val); - svqneg_x(svbool_t_val, svint64_t_val); - svqneg_z(svbool_t_val, svint8_t_val); - svqneg_z(svbool_t_val, svint16_t_val); - svqneg_z(svbool_t_val, svint32_t_val); - svqneg_z(svbool_t_val, svint64_t_val); - svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); - svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); - svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); - svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); - svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); - svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); - svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); - svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); - svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); - svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); - svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); - svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); - svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); - svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); - svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); - svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); - svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); - svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); - svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); - svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); - svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); - svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); - svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); - svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); - svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); - svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); - svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); - svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); - svqrdmulh(svint8_t_val, int8_t_val); - svqrdmulh(svint8_t_val, svint8_t_val); - svqrdmulh(svint16_t_val, int16_t_val); - svqrdmulh(svint16_t_val, svint16_t_val); - svqrdmulh(svint32_t_val, int32_t_val); - svqrdmulh(svint32_t_val, svint32_t_val); - svqrdmulh(svint64_t_val, int64_t_val); - svqrdmulh(svint64_t_val, svint64_t_val); - svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); - svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); - svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); - svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); - svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); - svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); - svqrdmulh_n_s8(svint8_t_val, int8_t_val); - svqrdmulh_n_s16(svint16_t_val, int16_t_val); - svqrdmulh_n_s32(svint32_t_val, int32_t_val); - svqrdmulh_n_s64(svint64_t_val, int64_t_val); - svqrdmulh_s8(svint8_t_val, svint8_t_val); - svqrdmulh_s16(svint16_t_val, svint16_t_val); - svqrdmulh_s32(svint32_t_val, svint32_t_val); - svqrdmulh_s64(svint64_t_val, svint64_t_val); - svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); - svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); - svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); - svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); - svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); - svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); - svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); - svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); - svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); - svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); - svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); - svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); - svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svqrshrnb(svint16_t_val, 2); - svqrshrnb(svint32_t_val, 2); - svqrshrnb(svint64_t_val, 2); - svqrshrnb(svuint16_t_val, 2); - svqrshrnb(svuint32_t_val, 2); - svqrshrnb(svuint64_t_val, 2); - svqrshrnb_n_s16(svint16_t_val, 2); - svqrshrnb_n_s32(svint32_t_val, 2); - svqrshrnb_n_s64(svint64_t_val, 2); - svqrshrnb_n_u16(svuint16_t_val, 2); - svqrshrnb_n_u32(svuint32_t_val, 2); - svqrshrnb_n_u64(svuint64_t_val, 2); - svqrshrnt(svint8_t_val, svint16_t_val, 2); - svqrshrnt(svint16_t_val, svint32_t_val, 2); - svqrshrnt(svint32_t_val, svint64_t_val, 2); - svqrshrnt(svuint8_t_val, svuint16_t_val, 2); - svqrshrnt(svuint16_t_val, svuint32_t_val, 2); - svqrshrnt(svuint32_t_val, svuint64_t_val, 2); - svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - svqrshrunb(svint16_t_val, 2); - svqrshrunb(svint32_t_val, 2); - svqrshrunb(svint64_t_val, 2); - svqrshrunb_n_s16(svint16_t_val, 2); - svqrshrunb_n_s32(svint32_t_val, 2); - svqrshrunb_n_s64(svint64_t_val, 2); - svqrshrunt(svuint8_t_val, svint16_t_val, 2); - svqrshrunt(svuint16_t_val, svint32_t_val, 2); - svqrshrunt(svuint32_t_val, svint64_t_val, 2); - svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); - svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); - svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); - svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); - svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); - svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); - svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); - svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); - svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); - svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); - svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); - svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); - svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); - svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); - svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); - svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svqshlu_m(svbool_t_val, svint8_t_val, 2); - svqshlu_m(svbool_t_val, svint16_t_val, 2); - svqshlu_m(svbool_t_val, svint32_t_val, 2); - svqshlu_m(svbool_t_val, svint64_t_val, 2); - svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); - svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); - svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); - svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); - svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); - svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); - svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); - svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); - svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); - svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); - svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); - svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); - svqshlu_x(svbool_t_val, svint8_t_val, 2); - svqshlu_x(svbool_t_val, svint16_t_val, 2); - svqshlu_x(svbool_t_val, svint32_t_val, 2); - svqshlu_x(svbool_t_val, svint64_t_val, 2); - svqshlu_z(svbool_t_val, svint8_t_val, 2); - svqshlu_z(svbool_t_val, svint16_t_val, 2); - svqshlu_z(svbool_t_val, svint32_t_val, 2); - svqshlu_z(svbool_t_val, svint64_t_val, 2); - svqshrnb(svint16_t_val, 2); - svqshrnb(svint32_t_val, 2); - svqshrnb(svint64_t_val, 2); - svqshrnb(svuint16_t_val, 2); - svqshrnb(svuint32_t_val, 2); - svqshrnb(svuint64_t_val, 2); - svqshrnb_n_s16(svint16_t_val, 2); - svqshrnb_n_s32(svint32_t_val, 2); - svqshrnb_n_s64(svint64_t_val, 2); - svqshrnb_n_u16(svuint16_t_val, 2); - svqshrnb_n_u32(svuint32_t_val, 2); - svqshrnb_n_u64(svuint64_t_val, 2); - svqshrnt(svint8_t_val, svint16_t_val, 2); - svqshrnt(svint16_t_val, svint32_t_val, 2); - svqshrnt(svint32_t_val, svint64_t_val, 2); - svqshrnt(svuint8_t_val, svuint16_t_val, 2); - svqshrnt(svuint16_t_val, svuint32_t_val, 2); - svqshrnt(svuint32_t_val, svuint64_t_val, 2); - svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - svqshrunb(svint16_t_val, 2); - svqshrunb(svint32_t_val, 2); - svqshrunb(svint64_t_val, 2); - svqshrunb_n_s16(svint16_t_val, 2); - svqshrunb_n_s32(svint32_t_val, 2); - svqshrunb_n_s64(svint64_t_val, 2); - svqshrunt(svuint8_t_val, svint16_t_val, 2); - svqshrunt(svuint16_t_val, svint32_t_val, 2); - svqshrunt(svuint32_t_val, svint64_t_val, 2); - svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); - svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); - svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); - svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); - svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); - svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); - svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); - svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); - svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); - svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); - svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); - svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); - svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); - svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); - svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); - svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); - svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); - svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); - svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); - svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); - svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); - svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); - svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); - svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); - svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); - svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); - svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); - svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); - svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); - svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); - svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); - svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); - svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); - svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); - svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); - svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svqxtnb(svint16_t_val); - svqxtnb(svint32_t_val); - svqxtnb(svint64_t_val); - svqxtnb(svuint16_t_val); - svqxtnb(svuint32_t_val); - svqxtnb(svuint64_t_val); - svqxtnb_s16(svint16_t_val); - svqxtnb_s32(svint32_t_val); - svqxtnb_s64(svint64_t_val); - svqxtnb_u16(svuint16_t_val); - svqxtnb_u32(svuint32_t_val); - svqxtnb_u64(svuint64_t_val); - svqxtnt(svint8_t_val, svint16_t_val); - svqxtnt(svint16_t_val, svint32_t_val); - svqxtnt(svint32_t_val, svint64_t_val); - svqxtnt(svuint8_t_val, svuint16_t_val); - svqxtnt(svuint16_t_val, svuint32_t_val); - svqxtnt(svuint32_t_val, svuint64_t_val); - svqxtnt_s16(svint8_t_val, svint16_t_val); - svqxtnt_s32(svint16_t_val, svint32_t_val); - svqxtnt_s64(svint32_t_val, svint64_t_val); - svqxtnt_u16(svuint8_t_val, svuint16_t_val); - svqxtnt_u32(svuint16_t_val, svuint32_t_val); - svqxtnt_u64(svuint32_t_val, svuint64_t_val); - svqxtunb(svint16_t_val); - svqxtunb(svint32_t_val); - svqxtunb(svint64_t_val); - svqxtunb_s16(svint16_t_val); - svqxtunb_s32(svint32_t_val); - svqxtunb_s64(svint64_t_val); - svqxtunt(svuint8_t_val, svint16_t_val); - svqxtunt(svuint16_t_val, svint32_t_val); - svqxtunt(svuint32_t_val, svint64_t_val); - svqxtunt_s16(svuint8_t_val, svint16_t_val); - svqxtunt_s32(svuint16_t_val, svint32_t_val); - svqxtunt_s64(svuint32_t_val, svint64_t_val); - svraddhnb(svint16_t_val, int16_t_val); - svraddhnb(svint16_t_val, svint16_t_val); - svraddhnb(svint32_t_val, int32_t_val); - svraddhnb(svint32_t_val, svint32_t_val); - svraddhnb(svint64_t_val, int64_t_val); - svraddhnb(svint64_t_val, svint64_t_val); - svraddhnb(svuint16_t_val, svuint16_t_val); - svraddhnb(svuint16_t_val, uint16_t_val); - svraddhnb(svuint32_t_val, svuint32_t_val); - svraddhnb(svuint32_t_val, uint32_t_val); - svraddhnb(svuint64_t_val, svuint64_t_val); - svraddhnb(svuint64_t_val, uint64_t_val); - svraddhnb_n_s16(svint16_t_val, int16_t_val); - svraddhnb_n_s32(svint32_t_val, int32_t_val); - svraddhnb_n_s64(svint64_t_val, int64_t_val); - svraddhnb_n_u16(svuint16_t_val, uint16_t_val); - svraddhnb_n_u32(svuint32_t_val, uint32_t_val); - svraddhnb_n_u64(svuint64_t_val, uint64_t_val); - svraddhnb_s16(svint16_t_val, svint16_t_val); - svraddhnb_s32(svint32_t_val, svint32_t_val); - svraddhnb_s64(svint64_t_val, svint64_t_val); - svraddhnb_u16(svuint16_t_val, svuint16_t_val); - svraddhnb_u32(svuint32_t_val, svuint32_t_val); - svraddhnb_u64(svuint64_t_val, svuint64_t_val); - svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); - svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); - svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); - svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); - svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); - svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); - svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - svrecpe_u32_x(svbool_t_val, svuint32_t_val); - svrecpe_u32_z(svbool_t_val, svuint32_t_val); - svrecpe_x(svbool_t_val, svuint32_t_val); - svrecpe_z(svbool_t_val, svuint32_t_val); - svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); - svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); - svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); - svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); - svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); - svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); - svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); - svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); - svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); - svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); - svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); - svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); - svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); - svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); - svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); - svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); - svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); - svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); - svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); - svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); - svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); - svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); - svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); - svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); - svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svrshr_m(svbool_t_val, svint8_t_val, 2); - svrshr_m(svbool_t_val, svint16_t_val, 2); - svrshr_m(svbool_t_val, svint32_t_val, 2); - svrshr_m(svbool_t_val, svint64_t_val, 2); - svrshr_m(svbool_t_val, svuint8_t_val, 2); - svrshr_m(svbool_t_val, svuint16_t_val, 2); - svrshr_m(svbool_t_val, svuint32_t_val, 2); - svrshr_m(svbool_t_val, svuint64_t_val, 2); - svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); - svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); - svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); - svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); - svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); - svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); - svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); - svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); - svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); - svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); - svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); - svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); - svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); - svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); - svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); - svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); - svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); - svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); - svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); - svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); - svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); - svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); - svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); - svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); - svrshr_x(svbool_t_val, svint8_t_val, 2); - svrshr_x(svbool_t_val, svint16_t_val, 2); - svrshr_x(svbool_t_val, svint32_t_val, 2); - svrshr_x(svbool_t_val, svint64_t_val, 2); - svrshr_x(svbool_t_val, svuint8_t_val, 2); - svrshr_x(svbool_t_val, svuint16_t_val, 2); - svrshr_x(svbool_t_val, svuint32_t_val, 2); - svrshr_x(svbool_t_val, svuint64_t_val, 2); - svrshr_z(svbool_t_val, svint8_t_val, 2); - svrshr_z(svbool_t_val, svint16_t_val, 2); - svrshr_z(svbool_t_val, svint32_t_val, 2); - svrshr_z(svbool_t_val, svint64_t_val, 2); - svrshr_z(svbool_t_val, svuint8_t_val, 2); - svrshr_z(svbool_t_val, svuint16_t_val, 2); - svrshr_z(svbool_t_val, svuint32_t_val, 2); - svrshr_z(svbool_t_val, svuint64_t_val, 2); - svrshrnb(svint16_t_val, 2); - svrshrnb(svint32_t_val, 2); - svrshrnb(svint64_t_val, 2); - svrshrnb(svuint16_t_val, 2); - svrshrnb(svuint32_t_val, 2); - svrshrnb(svuint64_t_val, 2); - svrshrnb_n_s16(svint16_t_val, 2); - svrshrnb_n_s32(svint32_t_val, 2); - svrshrnb_n_s64(svint64_t_val, 2); - svrshrnb_n_u16(svuint16_t_val, 2); - svrshrnb_n_u32(svuint32_t_val, 2); - svrshrnb_n_u64(svuint64_t_val, 2); - svrshrnt(svint8_t_val, svint16_t_val, 2); - svrshrnt(svint16_t_val, svint32_t_val, 2); - svrshrnt(svint32_t_val, svint64_t_val, 2); - svrshrnt(svuint8_t_val, svuint16_t_val, 2); - svrshrnt(svuint16_t_val, svuint32_t_val, 2); - svrshrnt(svuint32_t_val, svuint64_t_val, 2); - svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - svrsqrte_u32_x(svbool_t_val, svuint32_t_val); - svrsqrte_u32_z(svbool_t_val, svuint32_t_val); - svrsqrte_x(svbool_t_val, svuint32_t_val); - svrsqrte_z(svbool_t_val, svuint32_t_val); - svrsra(svint8_t_val, svint8_t_val, 2); - svrsra(svint16_t_val, svint16_t_val, 2); - svrsra(svint32_t_val, svint32_t_val, 2); - svrsra(svint64_t_val, svint64_t_val, 2); - svrsra(svuint8_t_val, svuint8_t_val, 2); - svrsra(svuint16_t_val, svuint16_t_val, 2); - svrsra(svuint32_t_val, svuint32_t_val, 2); - svrsra(svuint64_t_val, svuint64_t_val, 2); - svrsra_n_s8(svint8_t_val, svint8_t_val, 2); - svrsra_n_s16(svint16_t_val, svint16_t_val, 2); - svrsra_n_s32(svint32_t_val, svint32_t_val, 2); - svrsra_n_s64(svint64_t_val, svint64_t_val, 2); - svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); - svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); - svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); - svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); - svrsubhnb(svint16_t_val, int16_t_val); - svrsubhnb(svint16_t_val, svint16_t_val); - svrsubhnb(svint32_t_val, int32_t_val); - svrsubhnb(svint32_t_val, svint32_t_val); - svrsubhnb(svint64_t_val, int64_t_val); - svrsubhnb(svint64_t_val, svint64_t_val); - svrsubhnb(svuint16_t_val, svuint16_t_val); - svrsubhnb(svuint16_t_val, uint16_t_val); - svrsubhnb(svuint32_t_val, svuint32_t_val); - svrsubhnb(svuint32_t_val, uint32_t_val); - svrsubhnb(svuint64_t_val, svuint64_t_val); - svrsubhnb(svuint64_t_val, uint64_t_val); - svrsubhnb_n_s16(svint16_t_val, int16_t_val); - svrsubhnb_n_s32(svint32_t_val, int32_t_val); - svrsubhnb_n_s64(svint64_t_val, int64_t_val); - svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); - svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); - svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); - svrsubhnb_s16(svint16_t_val, svint16_t_val); - svrsubhnb_s32(svint32_t_val, svint32_t_val); - svrsubhnb_s64(svint64_t_val, svint64_t_val); - svrsubhnb_u16(svuint16_t_val, svuint16_t_val); - svrsubhnb_u32(svuint32_t_val, svuint32_t_val); - svrsubhnb_u64(svuint64_t_val, svuint64_t_val); - svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); - svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); - svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); - svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); - svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); - svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); - svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); - svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); - svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); - svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); - svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svshllb(svint8_t_val, 2); - svshllb(svint16_t_val, 2); - svshllb(svint32_t_val, 2); - svshllb(svuint8_t_val, 2); - svshllb(svuint16_t_val, 2); - svshllb(svuint32_t_val, 2); - svshllb_n_s16(svint8_t_val, 2); - svshllb_n_s32(svint16_t_val, 2); - svshllb_n_s64(svint32_t_val, 2); - svshllb_n_u16(svuint8_t_val, 2); - svshllb_n_u32(svuint16_t_val, 2); - svshllb_n_u64(svuint32_t_val, 2); - svshllt(svint8_t_val, 2); - svshllt(svint16_t_val, 2); - svshllt(svint32_t_val, 2); - svshllt(svuint8_t_val, 2); - svshllt(svuint16_t_val, 2); - svshllt(svuint32_t_val, 2); - svshllt_n_s16(svint8_t_val, 2); - svshllt_n_s32(svint16_t_val, 2); - svshllt_n_s64(svint32_t_val, 2); - svshllt_n_u16(svuint8_t_val, 2); - svshllt_n_u32(svuint16_t_val, 2); - svshllt_n_u64(svuint32_t_val, 2); - svshrnb(svint16_t_val, 2); - svshrnb(svint32_t_val, 2); - svshrnb(svint64_t_val, 2); - svshrnb(svuint16_t_val, 2); - svshrnb(svuint32_t_val, 2); - svshrnb(svuint64_t_val, 2); - svshrnb_n_s16(svint16_t_val, 2); - svshrnb_n_s32(svint32_t_val, 2); - svshrnb_n_s64(svint64_t_val, 2); - svshrnb_n_u16(svuint16_t_val, 2); - svshrnb_n_u32(svuint32_t_val, 2); - svshrnb_n_u64(svuint64_t_val, 2); - svshrnt(svint8_t_val, svint16_t_val, 2); - svshrnt(svint16_t_val, svint32_t_val, 2); - svshrnt(svint32_t_val, svint64_t_val, 2); - svshrnt(svuint8_t_val, svuint16_t_val, 2); - svshrnt(svuint16_t_val, svuint32_t_val, 2); - svshrnt(svuint32_t_val, svuint64_t_val, 2); - svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - svsli(svint8_t_val, svint8_t_val, 2); - svsli(svint16_t_val, svint16_t_val, 2); - svsli(svint32_t_val, svint32_t_val, 2); - svsli(svint64_t_val, svint64_t_val, 2); - svsli(svuint8_t_val, svuint8_t_val, 2); - svsli(svuint16_t_val, svuint16_t_val, 2); - svsli(svuint32_t_val, svuint32_t_val, 2); - svsli(svuint64_t_val, svuint64_t_val, 2); - svsli_n_s8(svint8_t_val, svint8_t_val, 2); - svsli_n_s16(svint16_t_val, svint16_t_val, 2); - svsli_n_s32(svint32_t_val, svint32_t_val, 2); - svsli_n_s64(svint64_t_val, svint64_t_val, 2); - svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); - svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); - svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); - svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); - svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); - svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); - svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); - svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); - svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); - svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); - svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); - svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); - svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); - svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); - svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); - svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); - svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); - svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); - svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); - svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); - svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); - svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); - svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); - svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); - svsra(svint8_t_val, svint8_t_val, 2); - svsra(svint16_t_val, svint16_t_val, 2); - svsra(svint32_t_val, svint32_t_val, 2); - svsra(svint64_t_val, svint64_t_val, 2); - svsra(svuint8_t_val, svuint8_t_val, 2); - svsra(svuint16_t_val, svuint16_t_val, 2); - svsra(svuint32_t_val, svuint32_t_val, 2); - svsra(svuint64_t_val, svuint64_t_val, 2); - svsra_n_s8(svint8_t_val, svint8_t_val, 2); - svsra_n_s16(svint16_t_val, svint16_t_val, 2); - svsra_n_s32(svint32_t_val, svint32_t_val, 2); - svsra_n_s64(svint64_t_val, svint64_t_val, 2); - svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); - svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); - svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); - svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); - svsri(svint8_t_val, svint8_t_val, 2); - svsri(svint16_t_val, svint16_t_val, 2); - svsri(svint32_t_val, svint32_t_val, 2); - svsri(svint64_t_val, svint64_t_val, 2); - svsri(svuint8_t_val, svuint8_t_val, 2); - svsri(svuint16_t_val, svuint16_t_val, 2); - svsri(svuint32_t_val, svuint32_t_val, 2); - svsri(svuint64_t_val, svuint64_t_val, 2); - svsri_n_s8(svint8_t_val, svint8_t_val, 2); - svsri_n_s16(svint16_t_val, svint16_t_val, 2); - svsri_n_s32(svint32_t_val, svint32_t_val, 2); - svsri_n_s64(svint64_t_val, svint64_t_val, 2); - svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); - svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); - svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); - svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); - svsubhnb(svint16_t_val, int16_t_val); - svsubhnb(svint16_t_val, svint16_t_val); - svsubhnb(svint32_t_val, int32_t_val); - svsubhnb(svint32_t_val, svint32_t_val); - svsubhnb(svint64_t_val, int64_t_val); - svsubhnb(svint64_t_val, svint64_t_val); - svsubhnb(svuint16_t_val, svuint16_t_val); - svsubhnb(svuint16_t_val, uint16_t_val); - svsubhnb(svuint32_t_val, svuint32_t_val); - svsubhnb(svuint32_t_val, uint32_t_val); - svsubhnb(svuint64_t_val, svuint64_t_val); - svsubhnb(svuint64_t_val, uint64_t_val); - svsubhnb_n_s16(svint16_t_val, int16_t_val); - svsubhnb_n_s32(svint32_t_val, int32_t_val); - svsubhnb_n_s64(svint64_t_val, int64_t_val); - svsubhnb_n_u16(svuint16_t_val, uint16_t_val); - svsubhnb_n_u32(svuint32_t_val, uint32_t_val); - svsubhnb_n_u64(svuint64_t_val, uint64_t_val); - svsubhnb_s16(svint16_t_val, svint16_t_val); - svsubhnb_s32(svint32_t_val, svint32_t_val); - svsubhnb_s64(svint64_t_val, svint64_t_val); - svsubhnb_u16(svuint16_t_val, svuint16_t_val); - svsubhnb_u32(svuint32_t_val, svuint32_t_val); - svsubhnb_u64(svuint64_t_val, svuint64_t_val); - svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); - svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); - svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); - svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); - svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); - svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); - svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - svsublb(svint8_t_val, int8_t_val); - svsublb(svint8_t_val, svint8_t_val); - svsublb(svint16_t_val, int16_t_val); - svsublb(svint16_t_val, svint16_t_val); - svsublb(svint32_t_val, int32_t_val); - svsublb(svint32_t_val, svint32_t_val); - svsublb(svuint8_t_val, svuint8_t_val); - svsublb(svuint8_t_val, uint8_t_val); - svsublb(svuint16_t_val, svuint16_t_val); - svsublb(svuint16_t_val, uint16_t_val); - svsublb(svuint32_t_val, svuint32_t_val); - svsublb(svuint32_t_val, uint32_t_val); - svsublb_n_s16(svint8_t_val, int8_t_val); - svsublb_n_s32(svint16_t_val, int16_t_val); - svsublb_n_s64(svint32_t_val, int32_t_val); - svsublb_n_u16(svuint8_t_val, uint8_t_val); - svsublb_n_u32(svuint16_t_val, uint16_t_val); - svsublb_n_u64(svuint32_t_val, uint32_t_val); - svsublb_s16(svint8_t_val, svint8_t_val); - svsublb_s32(svint16_t_val, svint16_t_val); - svsublb_s64(svint32_t_val, svint32_t_val); - svsublb_u16(svuint8_t_val, svuint8_t_val); - svsublb_u32(svuint16_t_val, svuint16_t_val); - svsublb_u64(svuint32_t_val, svuint32_t_val); - svsublbt(svint8_t_val, int8_t_val); - svsublbt(svint8_t_val, svint8_t_val); - svsublbt(svint16_t_val, int16_t_val); - svsublbt(svint16_t_val, svint16_t_val); - svsublbt(svint32_t_val, int32_t_val); - svsublbt(svint32_t_val, svint32_t_val); - svsublbt_n_s16(svint8_t_val, int8_t_val); - svsublbt_n_s32(svint16_t_val, int16_t_val); - svsublbt_n_s64(svint32_t_val, int32_t_val); - svsublbt_s16(svint8_t_val, svint8_t_val); - svsublbt_s32(svint16_t_val, svint16_t_val); - svsublbt_s64(svint32_t_val, svint32_t_val); - svsublt(svint8_t_val, int8_t_val); - svsublt(svint8_t_val, svint8_t_val); - svsublt(svint16_t_val, int16_t_val); - svsublt(svint16_t_val, svint16_t_val); - svsublt(svint32_t_val, int32_t_val); - svsublt(svint32_t_val, svint32_t_val); - svsublt(svuint8_t_val, svuint8_t_val); - svsublt(svuint8_t_val, uint8_t_val); - svsublt(svuint16_t_val, svuint16_t_val); - svsublt(svuint16_t_val, uint16_t_val); - svsublt(svuint32_t_val, svuint32_t_val); - svsublt(svuint32_t_val, uint32_t_val); - svsublt_n_s16(svint8_t_val, int8_t_val); - svsublt_n_s32(svint16_t_val, int16_t_val); - svsublt_n_s64(svint32_t_val, int32_t_val); - svsublt_n_u16(svuint8_t_val, uint8_t_val); - svsublt_n_u32(svuint16_t_val, uint16_t_val); - svsublt_n_u64(svuint32_t_val, uint32_t_val); - svsublt_s16(svint8_t_val, svint8_t_val); - svsublt_s32(svint16_t_val, svint16_t_val); - svsublt_s64(svint32_t_val, svint32_t_val); - svsublt_u16(svuint8_t_val, svuint8_t_val); - svsublt_u32(svuint16_t_val, svuint16_t_val); - svsublt_u64(svuint32_t_val, svuint32_t_val); - svsubltb(svint8_t_val, int8_t_val); - svsubltb(svint8_t_val, svint8_t_val); - svsubltb(svint16_t_val, int16_t_val); - svsubltb(svint16_t_val, svint16_t_val); - svsubltb(svint32_t_val, int32_t_val); - svsubltb(svint32_t_val, svint32_t_val); - svsubltb_n_s16(svint8_t_val, int8_t_val); - svsubltb_n_s32(svint16_t_val, int16_t_val); - svsubltb_n_s64(svint32_t_val, int32_t_val); - svsubltb_s16(svint8_t_val, svint8_t_val); - svsubltb_s32(svint16_t_val, svint16_t_val); - svsubltb_s64(svint32_t_val, svint32_t_val); - svsubwb(svint16_t_val, int8_t_val); - svsubwb(svint16_t_val, svint8_t_val); - svsubwb(svint32_t_val, int16_t_val); - svsubwb(svint32_t_val, svint16_t_val); - svsubwb(svint64_t_val, int32_t_val); - svsubwb(svint64_t_val, svint32_t_val); - svsubwb(svuint16_t_val, svuint8_t_val); - svsubwb(svuint16_t_val, uint8_t_val); - svsubwb(svuint32_t_val, svuint16_t_val); - svsubwb(svuint32_t_val, uint16_t_val); - svsubwb(svuint64_t_val, svuint32_t_val); - svsubwb(svuint64_t_val, uint32_t_val); - svsubwb_n_s16(svint16_t_val, int8_t_val); - svsubwb_n_s32(svint32_t_val, int16_t_val); - svsubwb_n_s64(svint64_t_val, int32_t_val); - svsubwb_n_u16(svuint16_t_val, uint8_t_val); - svsubwb_n_u32(svuint32_t_val, uint16_t_val); - svsubwb_n_u64(svuint64_t_val, uint32_t_val); - svsubwb_s16(svint16_t_val, svint8_t_val); - svsubwb_s32(svint32_t_val, svint16_t_val); - svsubwb_s64(svint64_t_val, svint32_t_val); - svsubwb_u16(svuint16_t_val, svuint8_t_val); - svsubwb_u32(svuint32_t_val, svuint16_t_val); - svsubwb_u64(svuint64_t_val, svuint32_t_val); - svsubwt(svint16_t_val, int8_t_val); - svsubwt(svint16_t_val, svint8_t_val); - svsubwt(svint32_t_val, int16_t_val); - svsubwt(svint32_t_val, svint16_t_val); - svsubwt(svint64_t_val, int32_t_val); - svsubwt(svint64_t_val, svint32_t_val); - svsubwt(svuint16_t_val, svuint8_t_val); - svsubwt(svuint16_t_val, uint8_t_val); - svsubwt(svuint32_t_val, svuint16_t_val); - svsubwt(svuint32_t_val, uint16_t_val); - svsubwt(svuint64_t_val, svuint32_t_val); - svsubwt(svuint64_t_val, uint32_t_val); - svsubwt_n_s16(svint16_t_val, int8_t_val); - svsubwt_n_s32(svint32_t_val, int16_t_val); - svsubwt_n_s64(svint64_t_val, int32_t_val); - svsubwt_n_u16(svuint16_t_val, uint8_t_val); - svsubwt_n_u32(svuint32_t_val, uint16_t_val); - svsubwt_n_u64(svuint64_t_val, uint32_t_val); - svsubwt_s16(svint16_t_val, svint8_t_val); - svsubwt_s32(svint32_t_val, svint16_t_val); - svsubwt_s64(svint64_t_val, svint32_t_val); - svsubwt_u16(svuint16_t_val, svuint8_t_val); - svsubwt_u32(svuint32_t_val, svuint16_t_val); - svsubwt_u64(svuint64_t_val, svuint32_t_val); - svtbl2(svbfloat16x2_t_val, svuint16_t_val); - svtbl2(svfloat16x2_t_val, svuint16_t_val); - svtbl2(svfloat32x2_t_val, svuint32_t_val); - svtbl2(svfloat64x2_t_val, svuint64_t_val); - svtbl2(svint8x2_t_val, svuint8_t_val); - svtbl2(svint16x2_t_val, svuint16_t_val); - svtbl2(svint32x2_t_val, svuint32_t_val); - svtbl2(svint64x2_t_val, svuint64_t_val); - svtbl2(svuint8x2_t_val, svuint8_t_val); - svtbl2(svuint16x2_t_val, svuint16_t_val); - svtbl2(svuint32x2_t_val, svuint32_t_val); - svtbl2(svuint64x2_t_val, svuint64_t_val); - svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); - svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); - svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); - svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); - svtbl2_s8(svint8x2_t_val, svuint8_t_val); - svtbl2_s16(svint16x2_t_val, svuint16_t_val); - svtbl2_s32(svint32x2_t_val, svuint32_t_val); - svtbl2_s64(svint64x2_t_val, svuint64_t_val); - svtbl2_u8(svuint8x2_t_val, svuint8_t_val); - svtbl2_u16(svuint16x2_t_val, svuint16_t_val); - svtbl2_u32(svuint32x2_t_val, svuint32_t_val); - svtbl2_u64(svuint64x2_t_val, svuint64_t_val); - svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); - svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); - svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); - svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); - svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); - svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); - svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); - svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); - svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); - svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); - svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); - svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); - svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); - svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); - svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); - svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); - svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); - svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); - svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); - svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); - svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); - svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); - svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); - svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); - svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); - svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); - svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); - svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); - svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); - svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); - svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); - svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); - svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); - svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); - svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); - svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); - svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); - svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); - svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); - svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); - svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); - svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); - svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); - svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); - svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); - svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); - svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); - svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); - svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); - svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); - svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); - svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); - svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); - svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); - svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); - svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); - svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); - svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); - svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); - svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); - svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); - svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); - svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); - svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); - svwhilege_b8(int32_t_val, int32_t_val); - svwhilege_b8(int64_t_val, int64_t_val); - svwhilege_b8(uint32_t_val, uint32_t_val); - svwhilege_b8(uint64_t_val, uint64_t_val); - svwhilege_b8_s32(int32_t_val, int32_t_val); - svwhilege_b8_s64(int64_t_val, int64_t_val); - svwhilege_b8_u32(uint32_t_val, uint32_t_val); - svwhilege_b8_u64(uint64_t_val, uint64_t_val); - svwhilege_b16(int32_t_val, int32_t_val); - svwhilege_b16(int64_t_val, int64_t_val); - svwhilege_b16(uint32_t_val, uint32_t_val); - svwhilege_b16(uint64_t_val, uint64_t_val); - svwhilege_b16_s32(int32_t_val, int32_t_val); - svwhilege_b16_s64(int64_t_val, int64_t_val); - svwhilege_b16_u32(uint32_t_val, uint32_t_val); - svwhilege_b16_u64(uint64_t_val, uint64_t_val); - svwhilege_b32(int32_t_val, int32_t_val); - svwhilege_b32(int64_t_val, int64_t_val); - svwhilege_b32(uint32_t_val, uint32_t_val); - svwhilege_b32(uint64_t_val, uint64_t_val); - svwhilege_b32_s32(int32_t_val, int32_t_val); - svwhilege_b32_s64(int64_t_val, int64_t_val); - svwhilege_b32_u32(uint32_t_val, uint32_t_val); - svwhilege_b32_u64(uint64_t_val, uint64_t_val); - svwhilege_b64(int32_t_val, int32_t_val); - svwhilege_b64(int64_t_val, int64_t_val); - svwhilege_b64(uint32_t_val, uint32_t_val); - svwhilege_b64(uint64_t_val, uint64_t_val); - svwhilege_b64_s32(int32_t_val, int32_t_val); - svwhilege_b64_s64(int64_t_val, int64_t_val); - svwhilege_b64_u32(uint32_t_val, uint32_t_val); - svwhilege_b64_u64(uint64_t_val, uint64_t_val); - svwhilegt_b8(int32_t_val, int32_t_val); - svwhilegt_b8(int64_t_val, int64_t_val); - svwhilegt_b8(uint32_t_val, uint32_t_val); - svwhilegt_b8(uint64_t_val, uint64_t_val); - svwhilegt_b8_s32(int32_t_val, int32_t_val); - svwhilegt_b8_s64(int64_t_val, int64_t_val); - svwhilegt_b8_u32(uint32_t_val, uint32_t_val); - svwhilegt_b8_u64(uint64_t_val, uint64_t_val); - svwhilegt_b16(int32_t_val, int32_t_val); - svwhilegt_b16(int64_t_val, int64_t_val); - svwhilegt_b16(uint32_t_val, uint32_t_val); - svwhilegt_b16(uint64_t_val, uint64_t_val); - svwhilegt_b16_s32(int32_t_val, int32_t_val); - svwhilegt_b16_s64(int64_t_val, int64_t_val); - svwhilegt_b16_u32(uint32_t_val, uint32_t_val); - svwhilegt_b16_u64(uint64_t_val, uint64_t_val); - svwhilegt_b32(int32_t_val, int32_t_val); - svwhilegt_b32(int64_t_val, int64_t_val); - svwhilegt_b32(uint32_t_val, uint32_t_val); - svwhilegt_b32(uint64_t_val, uint64_t_val); - svwhilegt_b32_s32(int32_t_val, int32_t_val); - svwhilegt_b32_s64(int64_t_val, int64_t_val); - svwhilegt_b32_u32(uint32_t_val, uint32_t_val); - svwhilegt_b32_u64(uint64_t_val, uint64_t_val); - svwhilegt_b64(int32_t_val, int32_t_val); - svwhilegt_b64(int64_t_val, int64_t_val); - svwhilegt_b64(uint32_t_val, uint32_t_val); - svwhilegt_b64(uint64_t_val, uint64_t_val); - svwhilegt_b64_s32(int32_t_val, int32_t_val); - svwhilegt_b64_s64(int64_t_val, int64_t_val); - svwhilegt_b64_u32(uint32_t_val, uint32_t_val); - svwhilegt_b64_u64(uint64_t_val, uint64_t_val); - svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - svwhilerw(float16_t_ptr_val, float16_t_ptr_val); - svwhilerw(float32_t_ptr_val, float32_t_ptr_val); - svwhilerw(float64_t_ptr_val, float64_t_ptr_val); - svwhilerw(int8_t_ptr_val, int8_t_ptr_val); - svwhilerw(int16_t_ptr_val, int16_t_ptr_val); - svwhilerw(int32_t_ptr_val, int32_t_ptr_val); - svwhilerw(int64_t_ptr_val, int64_t_ptr_val); - svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); - svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); - svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); - svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); - svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); - svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); - svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); - svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); - svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); - svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); - svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); - svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); - svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); - svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); - svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); - svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - svwhilewr(float16_t_ptr_val, float16_t_ptr_val); - svwhilewr(float32_t_ptr_val, float32_t_ptr_val); - svwhilewr(float64_t_ptr_val, float64_t_ptr_val); - svwhilewr(int8_t_ptr_val, int8_t_ptr_val); - svwhilewr(int16_t_ptr_val, int16_t_ptr_val); - svwhilewr(int32_t_ptr_val, int32_t_ptr_val); - svwhilewr(int64_t_ptr_val, int64_t_ptr_val); - svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); - svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); - svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); - svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); - svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); - svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); - svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); - svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); - svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); - svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); - svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); - svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); - svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); - svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); - svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); - svxar(svint8_t_val, svint8_t_val, 2); - svxar(svint16_t_val, svint16_t_val, 2); - svxar(svint32_t_val, svint32_t_val, 2); - svxar(svint64_t_val, svint64_t_val, 2); - svxar(svuint8_t_val, svuint8_t_val, 2); - svxar(svuint16_t_val, svuint16_t_val, 2); - svxar(svuint32_t_val, svuint32_t_val, 2); - svxar(svuint64_t_val, svuint64_t_val, 2); - svxar_n_s8(svint8_t_val, svint8_t_val, 2); - svxar_n_s16(svint16_t_val, svint16_t_val, 2); - svxar_n_s32(svint32_t_val, svint32_t_val, 2); - svxar_n_s64(svint64_t_val, svint64_t_val, 2); - svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); - svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); - svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); - svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); -} - -void test_streaming_compatible(void) __arm_streaming_compatible{ - bfloat16_t * bfloat16_t_ptr_val; - float16_t * float16_t_ptr_val; - float16_t float16_t_val; - float32_t * float32_t_ptr_val; - float64_t * float64_t_ptr_val; - int8_t * int8_t_ptr_val; - int8_t int8_t_val; - int16_t * int16_t_ptr_val; - int16_t int16_t_val; - int32_t * int32_t_ptr_val; - int32_t int32_t_val; - int64_t * int64_t_ptr_val; - int64_t int64_t_val; - svbfloat16_t svbfloat16_t_val; - svbfloat16x2_t svbfloat16x2_t_val; - svbool_t svbool_t_val; - svfloat16_t svfloat16_t_val; - svfloat16x2_t svfloat16x2_t_val; - svfloat32_t svfloat32_t_val; - svfloat32x2_t svfloat32x2_t_val; - svfloat64_t svfloat64_t_val; - svfloat64x2_t svfloat64x2_t_val; - svint8_t svint8_t_val; - svint8x2_t svint8x2_t_val; - svint16_t svint16_t_val; - svint16x2_t svint16x2_t_val; - svint32_t svint32_t_val; - svint32x2_t svint32x2_t_val; - svint64_t svint64_t_val; - svint64x2_t svint64x2_t_val; - svuint8_t svuint8_t_val; - svuint8x2_t svuint8x2_t_val; - svuint16_t svuint16_t_val; - svuint16x2_t svuint16x2_t_val; - svuint32_t svuint32_t_val; - svuint32x2_t svuint32x2_t_val; - svuint64_t svuint64_t_val; - svuint64x2_t svuint64x2_t_val; - uint8_t * uint8_t_ptr_val; - uint8_t uint8_t_val; - uint16_t * uint16_t_ptr_val; - uint16_t uint16_t_val; - uint32_t * uint32_t_ptr_val; - uint32_t uint32_t_val; - uint64_t * uint64_t_ptr_val; - uint64_t uint64_t_val; - - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svabdlt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlbt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddlt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwb_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svaddwt_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd(svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s8(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s16(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s32(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_s64(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u8(svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u16(svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u32(svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcadd_u64(svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtx_f32_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f16_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f16_z(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f32_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f32_z(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f64_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_f64_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_x(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_x(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_x(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_z(svbool_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_z(svbool_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svlogb_z(svbool_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_s16(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_s32(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_s64(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_u16(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_u32(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlb_u64(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_s16(svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_s32(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_s64(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_u16(svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_u32(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmovlt_u64(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane(svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_s16(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_s32(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_s64(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svmullt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul_n_u8(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmul_u8(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svpmullt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s8_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s8_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s16_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s16_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s32_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s32_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s64_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_s64_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqabs_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s8(svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s16(svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s32(svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqcadd_s64(svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s8(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s8(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmulh_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqdmullt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s8_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s8_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s16_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s16_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s32_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s32_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s64_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_s64_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_x(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqneg_z(svbool_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s8(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s8(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrdmulh_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshlu_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb(svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_s16(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_s32(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_s64(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_u16(svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_u32(svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnb_u64(svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svuint8_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svuint16_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt(svuint32_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_s16(svint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_s32(svint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_s64(svint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_u16(svuint8_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_u32(svuint16_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtnt_u64(svuint32_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb_s16(svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb_s32(svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunb_s64(svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt(svuint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt(svuint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt(svuint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt_s16(svuint8_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt_s32(svuint16_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svqxtunt_s64(svuint32_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_u32_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_u32_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrecpe_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_m(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_x(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshr_z(svbool_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_u32_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_u32_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_x(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsqrte_z(svbool_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_s16(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_s32(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_s64(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_u16(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_u32(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllb_n_u64(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_s16(svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_s32(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_s64(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_u16(svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_u32(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshllt_n_u64(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_s16(svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_s32(svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_s64(svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_u16(svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_u32(svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnb_n_u64(svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_s16(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_s32(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_s64(svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_u16(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_u32(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_n_u64(svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_s16(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_s32(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_s64(svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_u16(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_u32(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnb_u64(svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublb_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublbt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_u16(svuint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_u32(svuint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_n_u64(svuint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_u16(svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_u32(svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsublt_u64(svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_n_s16(svint8_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_n_s32(svint16_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_n_s64(svint32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_s16(svint8_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_s32(svint16_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubltb_s64(svint32_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwb_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_s16(svint16_t_val, int8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_s32(svint32_t_val, int16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_s64(svint64_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_u16(svuint16_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_u32(svuint32_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_n_u64(svuint64_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_s16(svint16_t_val, svint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_s32(svint32_t_val, svint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_s64(svint64_t_val, svint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_u16(svuint16_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_u32(svuint32_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svsubwt_u64(svuint64_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svbfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svfloat32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svfloat64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2(svuint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s8(svint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s16(svint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s32(svint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_s64(svint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u8(svuint8x2_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u16(svuint16x2_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u32(svuint32x2_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbl2_u64(svuint64x2_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b8_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b16_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b32_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilege_b64_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b8_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b16_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b32_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_s32(int32_t_val, int32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_s64(int64_t_val, int64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_u32(uint32_t_val, uint32_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilegt_b64_u64(uint64_t_val, uint64_t_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar(svuint64_t_val, svuint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s8(svint8_t_val, svint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s16(svint16_t_val, svint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s32(svint32_t_val, svint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_s64(svint64_t_val, svint64_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} - svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); -} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_sme2.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_LP_sve2p1_OR_sme2_RP.c index 104d0f3..07e275a 100644 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_sme2.c +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_LP_sve2p1_OR_sme2_RP.c @@ -1,14 +1,13 @@ // NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2p1 -verify=guard // RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard -// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2p1 -verify +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2p1 -verify // expected-no-diagnostics // REQUIRES: aarch64-registered-target #include <arm_sve.h> -// Properties: guard="sve,sve2p1" streaming_guard="sme,sme2" flags="feature-dependent" +// Properties: guard="sve,sve2p1" streaming_guard="sme,(sve2p1|sme2)" flags="feature-dependent" void test(void) { bfloat16_t * bfloat16_t_ptr_val; @@ -1114,1015 +1113,510 @@ void test_streaming(void) __arm_streaming{ uint64_t * uint64_t_ptr_val; uint64_t uint64_t_val; - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcntp_c8(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcntp_c16(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcntp_c32(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svcntp_c64(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_f16_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_f16_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_f32_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_f32_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_f64_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_f64_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s8_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s8_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s16_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s16_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s32_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s32_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s64_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_s64_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u8_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u8_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u16_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u16_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u32_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u32_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u64_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_u64_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svld1_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_f16_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_f16_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_f32_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_f32_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_f64_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_f64_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s8_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s8_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s16_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s16_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s32_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s32_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s64_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_s64_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u8_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u8_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u16_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u16_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u32_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u32_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u64_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_u64_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svldnt1_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c8(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c8_x2(svcount_t_val, 1); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c16(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c16_x2(svcount_t_val, 1); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c32(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c32_x2(svcount_t_val, 1); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c64(svcount_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpext_lane_c64_x2(svcount_t_val, 1); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpfalse_c(); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpsel_lane_c8(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpsel_lane_c16(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpsel_lane_c32(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svpsel_lane_c64(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svptrue_c8(); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svptrue_c16(); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svptrue_c32(); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svptrue_c64(); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svreinterpret(svbool_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svreinterpret(svcount_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svreinterpret_b(svcount_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svreinterpret_c(svbool_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svst1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svstnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c8(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c16(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c32(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilege_c64_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c8(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c16(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c32(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilegt_c64_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c8(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c16(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c32(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilele_c64_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c8(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c16(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c32(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+1 {{builtin can only be called from a non-streaming function}} svwhilelt_c64_u64(uint64_t_val, uint64_t_val, 2); } @@ -2172,1519 +1666,1014 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ uint64_t * uint64_t_ptr_val; uint64_t uint64_t_val; - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcntp_c8(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcntp_c16(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcntp_c32(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svcntp_c64(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_f16_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_f16_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_f32_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_f32_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_f64_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_f64_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s8_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s8_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s16_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s16_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s32_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s32_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s64_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_s64_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u8_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u8_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u16_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u16_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u32_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u32_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u64_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_u64_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svld1_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_f16_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_f16_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_f32_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_f32_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_f64_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_f64_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s8_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s8_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s16_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s16_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s32_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s32_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s64_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_s64_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u8_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u8_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u16_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u16_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u32_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u32_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u64_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_u64_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x2(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, bfloat16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, float16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, float32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, float64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, int8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, int16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, int32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, int64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, mfloat8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, uint8_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, uint16_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, uint32_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svldnt1_x4(svcount_t_val, uint64_t_ptr_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c8(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c8_x2(svcount_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c16(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c16_x2(svcount_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c32(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c32_x2(svcount_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c64(svcount_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpext_lane_c64_x2(svcount_t_val, 1); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpfalse_c(); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpsel_lane_c8(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpsel_lane_c16(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpsel_lane_c32(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svpsel_lane_c64(svcount_t_val, svbool_t_val, uint32_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svptrue_c8(); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svptrue_c16(); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svptrue_c32(); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svptrue_c64(); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svreinterpret(svbool_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svreinterpret(svcount_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svreinterpret_b(svcount_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svreinterpret_c(svbool_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svst1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svstnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c8(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c16(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c32(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilege_c64_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c8(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c16(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c32(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilegt_c64_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c8(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c16(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c32(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilele_c64_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c8(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c8(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c8_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c8_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c16(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c16(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c16_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c16_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c32(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c32(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c32_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c32_u64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c64(uint64_t_val, uint64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c64_s64(int64_t_val, int64_t_val, 2); - // guard-error@+2 {{builtin can only be called from a non-streaming function}} // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} svwhilelt_c64_u64(uint64_t_val, uint64_t_val, 2); } diff --git a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp index 4229f6c..313e043 100644 --- a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp +++ b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp @@ -40,1153 +40,1153 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svhistseg_s8' needs target feature sve,sve2}} // overload-error@+1 {{'svhistseg' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistseg,_s8,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmulh_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s8,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmulh_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s8,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqdmulh_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s8,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmulh_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s8,,)(svundef_s8(), i8); - // expected-error@+2 {{'svsra_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsra' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsra_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsra' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsra,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'svnbsl_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svnbsl_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svqabs_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s8,_z,)(pg, svundef_s8()); - // expected-error@+2 {{'svqabs_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s8,_m,)(svundef_s8(), pg, svundef_s8()); - // expected-error@+2 {{'svqabs_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s8,_x,)(pg, svundef_s8()); - // expected-error@+2 {{'svcadd_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcadd' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcadd_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcadd' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcadd,_s8,,)(svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svtbl2_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s8,,)(svundef2_s8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsubr_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsubr_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsubr_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsubr_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsubr_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'sveortb_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'sveortb_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svbcax_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbcax_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svqshlu_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshlu_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshlu_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshlu_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, svundef_s8(), 1); - // expected-error@+2 {{'svqrshl_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrshl_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrshl_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svcmla_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcmla' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcmla_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcmla' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcmla,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svqsubr_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsubr_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsubr_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsubr_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsubr_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsubr_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrshr_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshr_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, svundef_s8(), 1); - // expected-error@+2 {{'svaddp_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddp_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svtbx_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s8,,)(svundef_s8(), svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svqrdcmlah_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdcmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdcmlah_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdcmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svminp_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svminp_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsub_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsub_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrsra_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsra' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsra_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsra' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsra,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'sveor3_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'sveor3_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svhadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrdmlsh_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmlsh_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svmaxp_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmaxp_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s8,_x,)(pg, svundef_s8(), svundef_s8()); // expected-error@+2 {{'svmatch_s8' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_s8,,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svwhilerw_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s8,,)(const_i8_ptr, const_i8_ptr); - // expected-error@+2 {{'svqcadd_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqcadd' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqcadd_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqcadd' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqcadd,_s8,,)(svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svrhadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrhadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrhadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrhadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrhadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrhadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svwhilewr_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s8,,)(const_i8_ptr, const_i8_ptr); - // expected-error@+2 {{'svsli_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsli' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsli_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsli' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsli,_n_s8,,)(svundef_s8(), svundef_s8(), 1); // expected-error@+2 {{'svnmatch_s8' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_s8,,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaba_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaba_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svuqadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s8,_m,)(pg, svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svuqadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s8,_m,)(pg, svundef_s8(), u8); - // expected-error@+2 {{'svuqadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s8,_z,)(pg, svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svuqadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s8,_z,)(pg, svundef_s8(), u8); - // expected-error@+2 {{'svuqadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s8,_x,)(pg, svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svuqadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s8,_x,)(pg, svundef_s8(), u8); - // expected-error@+2 {{'sveorbt_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'sveorbt_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svbsl_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbsl_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svhsub_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsub_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsub_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsub_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsub_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsub_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrdmlah_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmlah_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svbsl2n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbsl2n_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svsri_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsri' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsri_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsri' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsri,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'svbsl1n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbsl1n_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svrshl_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrshl_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrshl_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrshl_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrshl_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrshl_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqneg_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s8,_z,)(pg, svundef_s8()); - // expected-error@+2 {{'svqneg_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s8,_m,)(svundef_s8(), pg, svundef_s8()); - // expected-error@+2 {{'svqneg_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s8,_x,)(pg, svundef_s8()); - // expected-error@+2 {{'svxar_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svxar' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svxar_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svxar' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svxar,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'svqshl_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqshl_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqshl_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqshl_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqshl_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqshl_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svmullb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmullb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqrshrunb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrunb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrunb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svqdmlalbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlalbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqrdmulh_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrdmulh_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqrdmulh_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svaddwb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svaddwb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_s16,,)(svundef_s16(), i8); - // expected-error@+2 {{'svsubhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsubhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmulh_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmulh_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmulh_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqshrunt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrunt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 1); - // expected-error@+2 {{'svrsubhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrsubhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svnbsl_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svnbsl_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlslb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svsubhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsubhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svqabs_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s16,_z,)(pg, svundef_s16()); - // expected-error@+2 {{'svqabs_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s16,_m,)(svundef_s16(), pg, svundef_s16()); - // expected-error@+2 {{'svqabs_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s16,_x,)(pg, svundef_s16()); - // expected-error@+2 {{'svaddlbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddlbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svtbl2_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s16,,)(svundef2_s16(), svundef_u16()); - // expected-error@+2 {{'svshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svhsubr_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsubr_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsubr_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsubr_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsubr_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsubr_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'sveortb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'sveortb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqxtnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_s16,,)(svundef_s16()); - // expected-error@+2 {{'svmlalt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlalt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svaddhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svmls_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmls_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmls_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmls_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmls_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmlalt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlalt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svbcax_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbcax_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqxtnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_s16,,)(svundef_s8(), svundef_s16()); - // expected-error@+2 {{'svqdmlalb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlalb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqrshl_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqrshl_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqrshl_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svsublbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsublbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmullt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmullt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svsublt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsublt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqdmlslbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlslbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svadalp_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s16,_z,)(pg, svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svadalp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s16,_m,)(pg, svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svadalp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s16,_x,)(pg, svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svmul_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmul_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmul_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmul_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmul_lane,_s16,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svsubwt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svsubwt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_s16,,)(svundef_s16(), i8); - // expected-error@+2 {{'svqsubr_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsubr_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsubr_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsubr_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsubr_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsubr_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqrshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svaddp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svabdlb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabdlb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svtbx_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s16,,)(svundef_s16(), svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svabdlt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabdlt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqrshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svminp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svminp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsub_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsub_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrsubhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrsubhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svaddhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svabalt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabalt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'sveor3_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'sveor3_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svhadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqshrunb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrunb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrunb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svmovlb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_s16,,)(svundef_s8()); - // expected-error@+2 {{'svqrdmlsh_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrdmlsh_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqrdmlsh_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmlslt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlslt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svmaxp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmaxp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmullt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmullt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_s16,,)(svundef_s8(), i8); // expected-error@+2 {{'svmatch_s16' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_s16,,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqxtunb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunb,_s16,,)(svundef_s16()); - // expected-error@+2 {{'svmla_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmla_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmla_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmla_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svrshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svwhilerw_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s16,,)(const_i16_ptr, const_i16_ptr); - // expected-error@+2 {{'svshllb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshllb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshllb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshllb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshllb,_n_s16,,)(svundef_s8(), 2); - // expected-error@+2 {{'svrhadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrhadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrhadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrhadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrhadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrhadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svraddhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svraddhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svwhilewr_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s16,,)(const_i16_ptr, const_i16_ptr); - // expected-error@+2 {{'svmlalb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlalb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svsubwb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svsubwb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_s16,,)(svundef_s16(), i8); // expected-error@+2 {{'svnmatch_s16' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_s16,,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaba_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaba_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svraddhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svraddhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svuqadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s16,_m,)(pg, svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svuqadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s16,_m,)(pg, svundef_s16(), u16); - // expected-error@+2 {{'svuqadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s16,_z,)(pg, svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svuqadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s16,_z,)(pg, svundef_s16(), u16); - // expected-error@+2 {{'svuqadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s16,_x,)(pg, svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svuqadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s16,_x,)(pg, svundef_s16(), u16); - // expected-error@+2 {{'sveorbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'sveorbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svbsl_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbsl_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svshllt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshllt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshllt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshllt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshllt,_n_s16,,)(svundef_s8(), 2); - // expected-error@+2 {{'svsubltb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsubltb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svhsub_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsub_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsub_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsub_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsub_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsub_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svaddlb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddlb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqrdmlah_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrdmlah_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqrdmlah_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmullb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmullb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svbsl2n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbsl2n_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svaddlt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddlt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqxtunt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunt,_s16,,)(svundef_u8(), svundef_s16()); - // expected-error@+2 {{'svqrshrunt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrunt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 1); - // expected-error@+2 {{'svabalb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabalb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svsublb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsublb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svbsl1n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbsl1n_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svrshl_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrshl_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrshl_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrshl_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrshl_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrshl_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svaddwt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svaddwt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_s16,,)(svundef_s16(), i8); - // expected-error@+2 {{'svmlslb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlslb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svmlslt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlslt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqneg_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s16,_z,)(pg, svundef_s16()); - // expected-error@+2 {{'svqneg_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s16,_m,)(svundef_s16(), pg, svundef_s16()); - // expected-error@+2 {{'svqneg_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s16,_x,)(pg, svundef_s16()); - // expected-error@+2 {{'svmovlt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_s16,,)(svundef_s8()); - // expected-error@+2 {{'svrshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svqshl_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqshl_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqshl_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqshl_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqshl_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqshl_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svmullb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmullb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svmullb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmlalbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlalbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqrdmulh_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrdmulh_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svaddwb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svaddwb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_s32,,)(svundef_s32(), i16); - // expected-error@+2 {{'svsubhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsubhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmulh_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmulh_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svrsubhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrsubhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); - // expected-error@+2 {{'svnbsl_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svnbsl_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqdmlslb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlslb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svsubhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsubhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); - // expected-error@+2 {{'svqabs_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s32,_z,)(pg, svundef_s32()); - // expected-error@+2 {{'svqabs_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s32,_m,)(svundef_s32(), pg, svundef_s32()); - // expected-error@+2 {{'svqabs_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s32,_x,)(pg, svundef_s32()); - // expected-error@+2 {{'svwhilegt_b8_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilegt_b16_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilegt_b32_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilegt_b64_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_s32,,)(i32, i32); - // expected-error@+2 {{'svaddlbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddlbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svtbl2_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s32,,)(svundef2_s32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsubr_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsubr_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsubr_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsubr_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsubr_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s32,_x,)(pg, svundef_s32(), i32); // expected-error@+2 {{'svhistcnt_s32_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveortb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveortb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqxtnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_s32,,)(svundef_s32()); - // expected-error@+2 {{'svmlalt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlalt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlalt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svaddhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); // expected-error@+2 {{'svldnt1uh_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_s32' needs target feature sve,sve2}} @@ -1200,233 +1200,233 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svqdmlalt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlalt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlalt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svbcax_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbcax_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqxtnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_s32,,)(svundef_s16(), svundef_s32()); - // expected-error@+2 {{'svqdmlalb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlalb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlalb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqrshl_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqrshl_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqrshl_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svcdot_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcdot' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcdot_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcdot' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcdot,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svsublbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsublbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmullt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmullt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmullt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svsublt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsublt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlslbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svadalp_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s32,_z,)(pg, svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svadalp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s32,_m,)(pg, svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svadalp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s32,_x,)(pg, svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svwhilege_b8_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilege_b16_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilege_b32_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilege_b64_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_s32,,)(i32, i32); - // expected-error@+2 {{'svsubwt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svsubwt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_s32,,)(svundef_s32(), i16); - // expected-error@+2 {{'svqsubr_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsubr_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsubr_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsubr_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsubr_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsubr_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svaddp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svabdlb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabdlb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svtbx_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s32,,)(svundef_s32(), svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svabdlt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabdlt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svminp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svminp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsub_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsub_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrsubhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrsubhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svaddhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svabalt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabalt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'sveor3_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveor3_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svhadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svmovlb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_s32,,)(svundef_s16()); // expected-error@+2 {{'svstnt1_scatter_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -1440,35 +1440,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _s32)(pg, svundef_u32(), i64, svundef_s32()); - // expected-error@+2 {{'svqrdmlsh_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrdmlsh_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqdmlslt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlslt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svmaxp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmaxp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmullt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmullt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svmullt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); // expected-error@+2 {{'svldnt1sh_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_s32' needs target feature sve,sve2}} @@ -1482,47 +1482,47 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svqxtunb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunb,_s32,,)(svundef_s32()); - // expected-error@+2 {{'svwhilerw_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s32,,)(const_i32_ptr, const_i32_ptr); - // expected-error@+2 {{'svrhadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrhadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrhadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrhadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrhadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrhadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svraddhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svraddhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svwhilewr_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s32,,)(const_i32_ptr, const_i32_ptr); - // expected-error@+2 {{'svmlalb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlalb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlalb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); // expected-error@+2 {{'svldnt1sb_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_s32' needs target feature sve,sve2}} @@ -1533,11 +1533,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u32base_offset_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svsubwb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svsubwb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_s32,,)(svundef_s32(), i16); // expected-error@+2 {{'svldnt1ub_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_s32' needs target feature sve,sve2}} @@ -1548,71 +1548,71 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u32base_offset_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaba_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaba_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svraddhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svraddhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); - // expected-error@+2 {{'svuqadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s32,_m,)(pg, svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svuqadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s32,_m,)(pg, svundef_s32(), u32); - // expected-error@+2 {{'svuqadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s32,_z,)(pg, svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svuqadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s32,_z,)(pg, svundef_s32(), u32); - // expected-error@+2 {{'svuqadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s32,_x,)(pg, svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svuqadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s32,_x,)(pg, svundef_s32(), u32); - // expected-error@+2 {{'sveorbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveorbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svbsl_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbsl_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svsubltb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsubltb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svhsub_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsub_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsub_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsub_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsub_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsub_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s32,_x,)(pg, svundef_s32(), i32); // expected-error@+2 {{'svldnt1_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_s32' needs target feature sve,sve2}} @@ -1626,26 +1626,26 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaddlb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddlb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqrdmlah_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrdmlah_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqdmullb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmullb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmullb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); // expected-error@+2 {{'svstnt1h_scatter_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve,sve2}} @@ -1668,243 +1668,243 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u32base_offset_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, _offset, _s32)(pg, svundef_u32(), i64, svundef_s32()); - // expected-error@+2 {{'svbsl2n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbsl2n_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svaddlt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddlt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqxtunt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunt,_s32,,)(svundef_u16(), svundef_s32()); - // expected-error@+2 {{'svabalb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabalb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svsublb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsublb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svbsl1n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbsl1n_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svrshl_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrshl_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrshl_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrshl_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrshl_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrshl_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svaddwt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svaddwt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_s32,,)(svundef_s32(), i16); - // expected-error@+2 {{'svmlslb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlslb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlslb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svmlslt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlslt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlslt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqneg_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s32,_z,)(pg, svundef_s32()); - // expected-error@+2 {{'svqneg_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s32,_m,)(svundef_s32(), pg, svundef_s32()); - // expected-error@+2 {{'svqneg_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s32,_x,)(pg, svundef_s32()); - // expected-error@+2 {{'svmovlt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_s32,,)(svundef_s16()); - // expected-error@+2 {{'svqshl_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqshl_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqshl_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqshl_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqshl_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqshl_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svmullb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmullb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmlalbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlalbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svqrdmulh_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrdmulh_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svaddwb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svaddwb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_s64,,)(svundef_s64(), i32); - // expected-error@+2 {{'svsubhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svsubhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svqdmulh_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqdmulh_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svrsubhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrsubhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); - // expected-error@+2 {{'svnbsl_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svnbsl_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqdmlslb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlslb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svsubhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svsubhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); - // expected-error@+2 {{'svqabs_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s64,_z,)(pg, svundef_s64()); - // expected-error@+2 {{'svqabs_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s64,_m,)(svundef_s64(), pg, svundef_s64()); - // expected-error@+2 {{'svqabs_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s64,_x,)(pg, svundef_s64()); - // expected-error@+2 {{'svwhilegt_b8_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilegt_b16_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilegt_b32_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilegt_b64_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_s64,,)(i64, i64); - // expected-error@+2 {{'svaddlbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddlbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svtbl2_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s64,,)(svundef2_s64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsubr_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsubr_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsubr_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsubr_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsubr_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s64,_x,)(pg, svundef_s64(), i64); // expected-error@+2 {{'svhistcnt_s64_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveortb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveortb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqxtnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_s64,,)(svundef_s64()); - // expected-error@+2 {{'svmlalt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlalt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svaddhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaddhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); // expected-error@+2 {{'svldnt1uh_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_s64' needs target feature sve,sve2}} @@ -1927,221 +1927,221 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqdmlalt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlalt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svbcax_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbcax_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqxtnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_s64,,)(svundef_s32(), svundef_s64()); - // expected-error@+2 {{'svqdmlalb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlalb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svqrshl_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqrshl_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqrshl_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svsublbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsublbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmullt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmullt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svsublt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsublt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmlslbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlslbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svadalp_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s64,_z,)(pg, svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svadalp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s64,_m,)(pg, svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svadalp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s64,_x,)(pg, svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svwhilege_b8_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilege_b16_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilege_b32_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilege_b64_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_s64,,)(i64, i64); - // expected-error@+2 {{'svsubwt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svsubwt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_s64,,)(svundef_s64(), i32); - // expected-error@+2 {{'svqsubr_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsubr_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsubr_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsubr_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsubr_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsubr_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svaddp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaddp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svabdlb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabdlb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svtbx_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s64,,)(svundef_s64(), svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svabdlt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabdlt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svminp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svminp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsub_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsub_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrsubhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrsubhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svaddhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaddhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svabalt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabalt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'sveor3_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveor3_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svhadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svmovlb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_s64,,)(svundef_s32()); // expected-error@+2 {{'svstnt1_scatter_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -2164,29 +2164,29 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64()); - // expected-error@+2 {{'svqrdmlsh_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrdmlsh_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqdmlslt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlslt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svmaxp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svmaxp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svmullt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmullt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_s64,,)(svundef_s32(), i32); // expected-error@+2 {{'svldnt1sh_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_s64' needs target feature sve,sve2}} @@ -2209,44 +2209,44 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqxtunb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunb,_s64,,)(svundef_s64()); - // expected-error@+2 {{'svwhilerw_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s64,,)(const_i64_ptr, const_i64_ptr); - // expected-error@+2 {{'svrhadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrhadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrhadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrhadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrhadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrhadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svraddhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svraddhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svwhilewr_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s64,,)(const_i64_ptr, const_i64_ptr); - // expected-error@+2 {{'svmlalb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlalb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); // expected-error@+2 {{'svldnt1sb_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_s64' needs target feature sve,sve2}} @@ -2260,11 +2260,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u64base_offset_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsubwb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svsubwb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_s64,,)(svundef_s64(), i32); // expected-error@+2 {{'svldnt1ub_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_s64' needs target feature sve,sve2}} @@ -2278,41 +2278,41 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u64base_offset_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaba_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaba_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svraddhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svraddhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); - // expected-error@+2 {{'svuqadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s64,_m,)(pg, svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svuqadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s64,_m,)(pg, svundef_s64(), u64); - // expected-error@+2 {{'svuqadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s64,_z,)(pg, svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svuqadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s64,_z,)(pg, svundef_s64(), u64); - // expected-error@+2 {{'svuqadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s64,_x,)(pg, svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svuqadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s64,_x,)(pg, svundef_s64(), u64); - // expected-error@+2 {{'sveorbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveorbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s64,,)(svundef_s64(), svundef_s64(), i64); // expected-error@+2 {{'svldnt1sw_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_s64' needs target feature sve,sve2}} @@ -2335,35 +2335,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sw_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svbsl_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbsl_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svsubltb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsubltb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svhsub_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsub_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsub_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsub_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsub_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsub_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s64,_x,)(pg, svundef_s64(), i64); // expected-error@+2 {{'svldnt1_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_s64' needs target feature sve,sve2}} @@ -2386,23 +2386,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaddlb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddlb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqrdmlah_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrdmlah_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqdmullb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmullb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_n_s64,,)(svundef_s32(), i32); // expected-error@+2 {{'svldnt1uw_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uw_gather_s64' needs target feature sve,sve2}} @@ -2458,17 +2458,17 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u64base_offset_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, _offset, _s64)(pg, svundef_u64(), i64, svundef_s64()); - // expected-error@+2 {{'svbsl2n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbsl2n_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svaddlt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddlt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_s64,,)(svundef_s32(), i32); // expected-error@+2 {{'svstnt1w_scatter_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter' needs target feature sve,sve2}} @@ -2491,980 +2491,980 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1w_scatter_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64()); - // expected-error@+2 {{'svqxtunt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunt,_s64,,)(svundef_u32(), svundef_s64()); - // expected-error@+2 {{'svabalb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabalb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svsublb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsublb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svbsl1n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbsl1n_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svrshl_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrshl_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrshl_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrshl_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrshl_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrshl_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svaddwt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svaddwt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_s64,,)(svundef_s64(), i32); - // expected-error@+2 {{'svmlslb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlslb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svmlslt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlslt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svqneg_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s64,_z,)(pg, svundef_s64()); - // expected-error@+2 {{'svqneg_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s64,_m,)(svundef_s64(), pg, svundef_s64()); - // expected-error@+2 {{'svqneg_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s64,_x,)(pg, svundef_s64()); - // expected-error@+2 {{'svmovlt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_s64,,)(svundef_s32()); - // expected-error@+2 {{'svqshl_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqshl_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqshl_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqshl_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqshl_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqshl_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s64,_x,)(pg, svundef_s64(), i64); // expected-error@+2 {{'svhistseg_u8' needs target feature sve,sve2}} // overload-error@+1 {{'svhistseg' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistseg,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullb_pair_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullb_pair_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_n_u8,,)(svundef_u8(), u8); - // expected-error@+2 {{'svnbsl_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svnbsl_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svtbl2_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u8,,)(svundef2_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsubr_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsubr_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svpmul_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmul' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmul_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmul' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmul,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmul_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmul' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmul_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmul' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmul,_n_u8,,)(svundef_u8(), u8); - // expected-error@+2 {{'sveortb_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'sveortb_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svbcax_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbcax_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svqrshl_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqrshl_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqrshl_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svpmullt_pair_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullt_pair_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_n_u8,,)(svundef_u8(), u8); - // expected-error@+2 {{'svqsubr_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsubr_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsubr_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsubr_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsubr_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsubr_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svaddp_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaddp_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svtbx_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svminp_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svminp_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svsqadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svsqadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svsqadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svsqadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svsqadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svsqadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqsub_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsub_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsub_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsub_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsub_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsub_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'sveor3_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'sveor3_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svhadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svmaxp_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmaxp_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u8,_x,)(pg, svundef_u8(), svundef_u8()); // expected-error@+2 {{'svmatch_u8' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_u8,,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svwhilerw_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u8,,)(const_u8_ptr, const_u8_ptr); - // expected-error@+2 {{'svrhadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svrhadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svrhadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svrhadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svrhadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svrhadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svwhilewr_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u8,,)(const_u8_ptr, const_u8_ptr); // expected-error@+2 {{'svnmatch_u8' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_u8,,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaba_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaba_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'sveorbt_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'sveorbt_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svbsl_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbsl_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svhsub_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsub_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsub_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsub_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsub_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsub_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svbsl2n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbsl2n_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svbsl1n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbsl1n_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svrshl_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svrshl_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svrshl_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svrshl_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svrshl_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svrshl_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqshl_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqshl_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqshl_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqshl_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqshl_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqshl_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svmullb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmullb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svpmullb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svaddwb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svaddwb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_u16,,)(svundef_u16(), u8); - // expected-error@+2 {{'svsubhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsubhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svrsubhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrsubhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'svnbsl_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svnbsl_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svsubhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsubhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'svtbl2_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u16,,)(svundef2_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsubr_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsubr_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'sveortb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'sveortb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svqxtnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_u16,,)(svundef_u16()); - // expected-error@+2 {{'svmlalt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlalt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svaddhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'svbcax_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbcax_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svqxtnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_u16,,)(svundef_u8(), svundef_u16()); - // expected-error@+2 {{'svqrshl_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqrshl_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqrshl_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svsublt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svsublt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svadalp_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u16,_z,)(pg, svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svadalp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u16,_m,)(pg, svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svadalp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u16,_x,)(pg, svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svpmullt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svsubwt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svsubwt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_u16,,)(svundef_u16(), u8); - // expected-error@+2 {{'svqsubr_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsubr_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsubr_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsubr_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsubr_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsubr_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svaddp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svabdlb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabdlb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svtbx_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabdlt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabdlt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svminp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svminp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsqadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svsqadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svsqadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svsqadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svsqadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svsqadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqsub_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsub_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsub_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsub_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsub_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsub_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svrsubhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrsubhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svaddhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svabalt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabalt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'sveor3_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'sveor3_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svhadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svmovlb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_u16,,)(svundef_u8()); - // expected-error@+2 {{'svmaxp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmaxp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmullt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmullt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_u16,,)(svundef_u8(), u8); // expected-error@+2 {{'svmatch_u16' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_u16,,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svwhilerw_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u16,,)(const_u16_ptr, const_u16_ptr); - // expected-error@+2 {{'svrhadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrhadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svrhadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrhadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svrhadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrhadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svraddhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svraddhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svwhilewr_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u16,,)(const_u16_ptr, const_u16_ptr); - // expected-error@+2 {{'svmlalb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlalb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svsubwb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svsubwb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_u16,,)(svundef_u16(), u8); // expected-error@+2 {{'svnmatch_u16' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_u16,,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaba_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaba_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svraddhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svraddhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'sveorbt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'sveorbt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svbsl_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbsl_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svhsub_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsub_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsub_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsub_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsub_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsub_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svaddlb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaddlb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svbsl2n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbsl2n_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svaddlt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaddlt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svabalb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabalb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svsublb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svsublb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svbsl1n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbsl1n_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svrshl_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svrshl_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svrshl_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svrshl_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svrshl_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svrshl_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svaddwt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svaddwt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_u16,,)(svundef_u16(), u8); - // expected-error@+2 {{'svmlslb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlslb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svmlslt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlslt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svmovlt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_u16,,)(svundef_u8()); - // expected-error@+2 {{'svqshl_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqshl_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqshl_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqshl_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqshl_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqshl_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svmullb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmullb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svpmullb_pair_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullb_pair_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svaddwb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svaddwb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_u32,,)(svundef_u32(), u16); - // expected-error@+2 {{'svsubhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsubhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svrsubhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrsubhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); - // expected-error@+2 {{'svnbsl_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svnbsl_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svsubhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsubhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); - // expected-error@+2 {{'svwhilegt_b8_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilegt_b16_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilegt_b32_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilegt_b64_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_u32,,)(u32, u32); - // expected-error@+2 {{'svtbl2_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u32,,)(svundef2_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsubr_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsubr_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u32,_x,)(pg, svundef_u32(), u32); // expected-error@+2 {{'svhistcnt_u32_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveortb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveortb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svqxtnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_u32,,)(svundef_u32()); - // expected-error@+2 {{'svmlalt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlalt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svaddhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); // expected-error@+2 {{'svldnt1uh_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_u32' needs target feature sve,sve2}} @@ -3478,230 +3478,230 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svbcax_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbcax_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svqxtnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_u32,,)(svundef_u16(), svundef_u32()); - // expected-error@+2 {{'svqrshl_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqrshl_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqrshl_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svsublt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsublt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svadalp_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u32,_z,)(pg, svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svadalp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u32,_m,)(pg, svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svadalp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u32,_x,)(pg, svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svwhilege_b8_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilege_b16_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilege_b32_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilege_b64_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_u32,,)(u32, u32); - // expected-error@+2 {{'svpmullt_pair_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullt_pair_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svsubwt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svsubwt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_u32,,)(svundef_u32(), u16); - // expected-error@+2 {{'svqsubr_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsubr_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsubr_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsubr_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsubr_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsubr_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svadclt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svadclt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svaddp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrecpe_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrecpe_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrecpe_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrecpe_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrecpe,_u32,_z,)(pg, svundef_u32()); - // expected-error@+2 {{'svrecpe_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrecpe_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrecpe_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrecpe_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrecpe,_u32,_m,)(svundef_u32(), pg, svundef_u32()); - // expected-error@+2 {{'svrecpe_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrecpe_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrecpe_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrecpe_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrecpe,_u32,_x,)(pg, svundef_u32()); - // expected-error@+2 {{'svqadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svabdlb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabdlb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svtbx_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabdlt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabdlt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svminp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svminp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsqadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svsqadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svsqadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svsqadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svsqadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svsqadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqsub_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsub_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsub_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsub_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsub_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsub_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svrsubhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrsubhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svaddhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svabalt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabalt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'sveor3_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveor3_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svhadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svmovlb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_u32,,)(svundef_u16()); // expected-error@+2 {{'svstnt1_scatter_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -3715,23 +3715,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _u32)(pg, svundef_u32(), i64, svundef_u32()); - // expected-error@+2 {{'svmaxp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmaxp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsbclt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsbclt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svmullt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmullt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_u32,,)(svundef_u16(), u16); // expected-error@+2 {{'svldnt1sh_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_u32' needs target feature sve,sve2}} @@ -3745,41 +3745,41 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svwhilerw_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u32,,)(const_u32_ptr, const_u32_ptr); - // expected-error@+2 {{'svrhadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrhadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svrhadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrhadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svrhadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrhadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svraddhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svraddhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svwhilewr_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u32,,)(const_u32_ptr, const_u32_ptr); - // expected-error@+2 {{'svmlalb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlalb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_u32,,)(svundef_u32(), svundef_u16(), u16); // expected-error@+2 {{'svldnt1sb_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_u32' needs target feature sve,sve2}} @@ -3790,11 +3790,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u32base_offset_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svsubwb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svsubwb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_u32,,)(svundef_u32(), u16); // expected-error@+2 {{'svldnt1ub_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_u32' needs target feature sve,sve2}} @@ -3805,53 +3805,53 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u32base_offset_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaba_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaba_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svraddhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svraddhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); - // expected-error@+2 {{'sveorbt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveorbt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svbsl_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbsl_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svadclb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svadclb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svhsub_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsub_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsub_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsub_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsub_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsub_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u32,_x,)(pg, svundef_u32(), u32); // expected-error@+2 {{'svldnt1_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_u32' needs target feature sve,sve2}} @@ -3865,11 +3865,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaddlb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddlb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_u32,,)(svundef_u16(), u16); // expected-error@+2 {{'svstnt1h_scatter_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve,sve2}} @@ -3892,207 +3892,207 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u32base_offset_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, _offset, _u32)(pg, svundef_u32(), i64, svundef_u32()); - // expected-error@+2 {{'svbsl2n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbsl2n_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svaddlt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddlt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svabalb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabalb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svsublb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsublb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svsbclb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsbclb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svbsl1n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbsl1n_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svrshl_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svrshl_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svrshl_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svrshl_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svrshl_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svrshl_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svrsqrte_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsqrte_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsqrte_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsqrte_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsqrte,_u32,_z,)(pg, svundef_u32()); - // expected-error@+2 {{'svrsqrte_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsqrte_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsqrte_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsqrte_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsqrte,_u32,_m,)(svundef_u32(), pg, svundef_u32()); - // expected-error@+2 {{'svrsqrte_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsqrte_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsqrte_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsqrte_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsqrte,_u32,_x,)(pg, svundef_u32()); - // expected-error@+2 {{'svaddwt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svaddwt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_u32,,)(svundef_u32(), u16); - // expected-error@+2 {{'svmlslb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlslb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svmlslt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlslt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svmovlt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_u32,,)(svundef_u16()); - // expected-error@+2 {{'svqshl_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqshl_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqshl_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqshl_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqshl_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqshl_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svmullb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmullb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svpmullb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svaddwb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svaddwb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_u64,,)(svundef_u64(), u32); - // expected-error@+2 {{'svsubhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsubhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svrsubhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrsubhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); - // expected-error@+2 {{'svnbsl_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svnbsl_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svsubhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsubhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); - // expected-error@+2 {{'svwhilegt_b8_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilegt_b16_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilegt_b32_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilegt_b64_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_u64,,)(u64, u64); - // expected-error@+2 {{'svtbl2_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u64,,)(svundef2_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsubr_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsubr_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u64,_x,)(pg, svundef_u64(), u64); // expected-error@+2 {{'svhistcnt_u64_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveortb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveortb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svqxtnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_u64,,)(svundef_u64()); - // expected-error@+2 {{'svmlalt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlalt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svaddhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaddhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); // expected-error@+2 {{'svldnt1uh_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_u64' needs target feature sve,sve2}} @@ -4115,221 +4115,221 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svbcax_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbcax_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svqxtnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_u64,,)(svundef_u32(), svundef_u64()); - // expected-error@+2 {{'svqrshl_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqrshl_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqrshl_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsublt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsublt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svadalp_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u64,_z,)(pg, svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svadalp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u64,_m,)(pg, svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svadalp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u64,_x,)(pg, svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svwhilege_b8_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilege_b16_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilege_b32_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilege_b64_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_u64,,)(u64, u64); - // expected-error@+2 {{'svpmullt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svsubwt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svsubwt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_u64,,)(svundef_u64(), u32); - // expected-error@+2 {{'svqsubr_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsubr_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsubr_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsubr_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsubr_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsubr_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svadclt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svadclt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svaddp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaddp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svabdlb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabdlb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svtbx_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svabdlt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabdlt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svminp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svminp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsqadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svsqadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsqadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svsqadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsqadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svsqadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqsub_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsub_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsub_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsub_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsub_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsub_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svrsubhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrsubhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svaddhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaddhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svabalt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabalt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'sveor3_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveor3_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svhadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svmovlb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_u64,,)(svundef_u32()); // expected-error@+2 {{'svstnt1_scatter_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -4352,23 +4352,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64()); - // expected-error@+2 {{'svmaxp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svmaxp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsbclt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsbclt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svmullt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmullt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_u64,,)(svundef_u32(), u32); // expected-error@+2 {{'svldnt1sh_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_u64' needs target feature sve,sve2}} @@ -4391,41 +4391,41 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svwhilerw_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u64,,)(const_u64_ptr, const_u64_ptr); - // expected-error@+2 {{'svrhadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrhadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svrhadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrhadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svrhadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrhadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svraddhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svraddhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svwhilewr_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u64,,)(const_u64_ptr, const_u64_ptr); - // expected-error@+2 {{'svmlalb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlalb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_u64,,)(svundef_u64(), svundef_u32(), u32); // expected-error@+2 {{'svldnt1sb_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_u64' needs target feature sve,sve2}} @@ -4439,11 +4439,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u64base_offset_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsubwb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svsubwb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_u64,,)(svundef_u64(), u32); // expected-error@+2 {{'svldnt1ub_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_u64' needs target feature sve,sve2}} @@ -4457,23 +4457,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u64base_offset_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaba_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaba_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svraddhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svraddhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); - // expected-error@+2 {{'sveorbt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveorbt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u64,,)(svundef_u64(), svundef_u64(), u64); // expected-error@+2 {{'svldnt1sw_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_u64' needs target feature sve,sve2}} @@ -4496,35 +4496,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sw_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svbsl_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbsl_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svadclb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svadclb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svhsub_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsub_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsub_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsub_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsub_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsub_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u64,_x,)(pg, svundef_u64(), u64); // expected-error@+2 {{'svldnt1_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_u64' needs target feature sve,sve2}} @@ -4547,11 +4547,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaddlb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddlb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_u64,,)(svundef_u32(), u32); // expected-error@+2 {{'svldnt1uw_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uw_gather_u64' needs target feature sve,sve2}} @@ -4607,17 +4607,17 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u64base_offset_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, _offset, _u64)(pg, svundef_u64(), i64, svundef_u64()); - // expected-error@+2 {{'svbsl2n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbsl2n_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svaddlt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddlt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_u64,,)(svundef_u32(), u32); // expected-error@+2 {{'svstnt1w_scatter_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter' needs target feature sve,sve2}} @@ -4640,178 +4640,178 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1w_scatter_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64()); - // expected-error@+2 {{'svabalb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabalb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svsublb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsublb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svsbclb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsbclb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svbsl1n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbsl1n_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svrshl_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svrshl_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svrshl_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svrshl_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svrshl_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svrshl_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaddwt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svaddwt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_u64,,)(svundef_u64(), u32); - // expected-error@+2 {{'svmlslb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlslb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svmlslt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlslt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svmovlt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_u64,,)(svundef_u32()); - // expected-error@+2 {{'svqshl_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqshl_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqshl_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqshl_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqshl_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqshl_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svlogb_f16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f16,_z,)(pg, svundef_f16()); - // expected-error@+2 {{'svlogb_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f16,_m,)(svundef_s16(), pg, svundef_f16()); - // expected-error@+2 {{'svlogb_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f16,_x,)(pg, svundef_f16()); - // expected-error@+2 {{'svminnmp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svminnmp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svtbl2_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_f16,,)(svundef2_f16(), svundef_u16()); - // expected-error@+2 {{'svaddp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svaddp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svtbx_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_f16,,)(svundef_f16(), svundef_f16(), svundef_u16()); - // expected-error@+2 {{'svminp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svminp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxnmp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxnmp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svwhilerw_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_f16,,)(const_f16_ptr, const_f16_ptr); - // expected-error@+2 {{'svwhilewr_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_f16,,)(const_f16_ptr, const_f16_ptr); - // expected-error@+2 {{'svcvtlt_f32_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f32_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f32,_f16,_m,)(svundef_f32(), pg, svundef_f16()); - // expected-error@+2 {{'svcvtlt_f32_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f32_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f32_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f32_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f32,_f16,_x,)(pg, svundef_f16()); - // expected-error@+2 {{'svlogb_f32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f32,_z,)(pg, svundef_f32()); - // expected-error@+2 {{'svlogb_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f32,_m,)(svundef_s32(), pg, svundef_f32()); - // expected-error@+2 {{'svlogb_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f32,_x,)(pg, svundef_f32()); - // expected-error@+2 {{'svminnmp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svminnmp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svtbl2_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_f32,,)(svundef2_f32(), svundef_u32()); - // expected-error@+2 {{'svaddp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svaddp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svtbx_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_f32,,)(svundef_f32(), svundef_f32(), svundef_u32()); - // expected-error@+2 {{'svminp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svminp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); // expected-error@+2 {{'svstnt1_scatter_u32base_f32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -4825,35 +4825,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u32base_index_f32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _f32)(pg, svundef_u32(), i64, svundef_f32()); - // expected-error@+2 {{'svmaxp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svmaxp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svmaxnmp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svmaxnmp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svwhilerw_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_f32,,)(const_f32_ptr, const_f32_ptr); - // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f16,_f32,_m,)(svundef_f16(), pg, svundef_f32()); - // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f16,_f32,_x,)(svundef_f16(), pg, svundef_f32()); - // expected-error@+2 {{'svwhilewr_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_f32,,)(const_f32_ptr, const_f32_ptr); - // expected-error@+2 {{'svcvtlt_f64_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f64_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f64_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f64_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f64,_f32,_m,)(svundef_f64(), pg, svundef_f32()); - // expected-error@+2 {{'svcvtlt_f64_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f64_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f64_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f64_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f64,_f32,_x,)(pg, svundef_f32()); // expected-error@+2 {{'svldnt1_gather_u32base_f32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_f32' needs target feature sve,sve2}} @@ -4868,38 +4868,38 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // overload-error@+1 {{'svldnt1_gather_index_f32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_f32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svlogb_f64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f64,_z,)(pg, svundef_f64()); - // expected-error@+2 {{'svlogb_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f64,_m,)(svundef_s64(), pg, svundef_f64()); - // expected-error@+2 {{'svlogb_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f64,_x,)(pg, svundef_f64()); - // expected-error@+2 {{'svminnmp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svminnmp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svtbl2_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_f64,,)(svundef2_f64(), svundef_u64()); - // expected-error@+2 {{'svaddp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svaddp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svtbx_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_f64,,)(svundef_f64(), svundef_f64(), svundef_u64()); - // expected-error@+2 {{'svminp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svminp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); // expected-error@+2 {{'svstnt1_scatter_u64base_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -4922,38 +4922,38 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u64base_index_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _f64)(pg, svundef_u64(), i64, svundef_f64()); - // expected-error@+2 {{'svmaxp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svmaxp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svmaxnmp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svmaxnmp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svwhilerw_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_f64,,)(const_f64_ptr, const_f64_ptr); - // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f32,_f64,_x,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svwhilewr_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_f64,,)(const_f64_ptr, const_f64_ptr); - // expected-error@+2 {{'svcvtx_f32_f64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtx_f32_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtx_f32_f64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtx_f32_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtx_f32,_f64,_z,)(pg, svundef_f64()); - // expected-error@+2 {{'svcvtx_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtx_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtx_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtx_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtx_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svcvtx_f32_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtx_f32_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtx_f32_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtx_f32_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtx_f32,_f64,_x,)(pg, svundef_f64()); // expected-error@+2 {{'svldnt1_gather_u64base_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_f64' needs target feature sve,sve2}} @@ -4976,10 +4976,10 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u64base_index_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_f64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_f64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtxnt_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtxnt_f32,_f64,_x,)(svundef_f32(), pg, svundef_f64()); } diff --git a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp index b251701..014e7d4 100644 --- a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp +++ b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp @@ -119,10 +119,10 @@ void test(uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64) // expected-error@+2 {{'svpmullt_pair_n_u64' needs target feature (sve,sve-aes)|(sme,ssve-aes)}}} // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve-aes)|(sme,ssve-aes)}}} SVE_ACLE_FUNC(svpmullt_pair,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svrax1_u64' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} - // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} + // expected-error@+2 {{'svrax1_u64' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} + // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} SVE_ACLE_FUNC(svrax1,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrax1_s64' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} - // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} + // expected-error@+2 {{'svrax1_s64' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} + // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} SVE_ACLE_FUNC(svrax1,_s64,,)(svundef_s64(), svundef_s64()); } diff --git a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c index 192d200..684d990 100644 --- a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c +++ b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c @@ -6,30 +6,30 @@ void test_features(svmfloat8_t zn, svmfloat8_t zm, mfloat8_t x, fpm_t fpm) { svcvt1_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt1_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt1_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvt2_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt2_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt2_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt1_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt1_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt1_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt2_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt2_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt2_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvt1_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt1_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt1_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvt2_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt2_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt2_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt1_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt1_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt1_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt2_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt2_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt2_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtn_mf8_bf16_x2_fpm(svcreate2(svundef_bf16(), svundef_bf16()), fpm); - // expected-error@-1 {{'svcvtn_mf8_bf16_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtn_mf8_bf16_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtn_mf8_f16_x2_fpm(svcreate2(svundef_f16(), svundef_f16()), fpm); - // expected-error@-1 {{'svcvtn_mf8_f16_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtn_mf8_f16_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtnb_mf8_f32_x2_fpm(svcreate2(svundef_f32(), svundef_f32()), fpm); - // expected-error@-1 {{'svcvtnb_mf8_f32_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtnb_mf8_f32_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtnt_mf8_f32_x2_fpm(zn, svcreate2(svundef_f32(), svundef_f32()), fpm); - // expected-error@-1 {{'svcvtnt_mf8_f32_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtnt_mf8_f32_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svdot_f32_mf8_fpm(svundef_f32(), zn, zm, fpm); // expected-error@-1 {{'svdot_f32_mf8_fpm' needs target feature (sve,sve2,fp8dot4)|(sme,ssve-fp8dot4)}} diff --git a/clang/test/Sema/internal_linkage.c b/clang/test/Sema/internal_linkage.c index a1bff73..4ea8599 100644 --- a/clang/test/Sema/internal_linkage.c +++ b/clang/test/Sema/internal_linkage.c @@ -20,7 +20,7 @@ struct __attribute__((internal_linkage)) S { // expected-warning{{'internal_link __attribute__((internal_linkage("foo"))) int g(void) {} // expected-error{{'internal_linkage' attribute takes no arguments}} int var6 [[clang::internal_linkage]]; -int var7 [[clang::internal_linkage]] __attribute__((common)); // expected-error{{'clang::internal_linkage' and 'common' attributes are not compatible}} \ +int var7 [[clang::internal_linkage]] __attribute__((common)); // expected-error{{'common' and 'clang::internal_linkage' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} __attribute__((common)) int var8 [[clang::internal_linkage]]; // expected-error{{'clang::internal_linkage' and 'common' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} diff --git a/clang/test/SemaOpenCL/address-spaces.cl b/clang/test/SemaOpenCL/address-spaces.cl index 86435b7..6c3ee89 100644 --- a/clang/test/SemaOpenCL/address-spaces.cl +++ b/clang/test/SemaOpenCL/address-spaces.cl @@ -265,7 +265,8 @@ void func_multiple_addr2(void) { __attribute__((opencl_private)) private_int_t var5; // expected-warning {{multiple identical address spaces specified for type}} __attribute__((opencl_private)) private_int_t *var6; // expected-warning {{multiple identical address spaces specified for type}} #if __OPENCL_CPP_VERSION__ - __global int [[clang::opencl_private]] var7; // expected-error {{multiple address spaces specified for type}} + __global int [[clang::opencl_private]] var7; // expected-error {{multiple address spaces specified for type}} \ + // expected-error {{function scope variable cannot be declared in global address space}} __global int [[clang::opencl_private]] *var8; // expected-error {{multiple address spaces specified for type}} private_int_t [[clang::opencl_private]] var9; // expected-warning {{multiple identical address spaces specified for type}} private_int_t [[clang::opencl_private]] *var10; // expected-warning {{multiple identical address spaces specified for type}} diff --git a/clang/test/SemaOpenCL/builtins-image-load-param-gfx1100-err.cl b/clang/test/SemaOpenCL/builtins-image-load-param-gfx1100-err.cl new file mode 100644 index 0000000..8f609dc --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-load-param-gfx1100-err.cl @@ -0,0 +1,194 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1100 -S -verify=expected -o - %s +// REQUIRES: amdgpu-registered-target + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +float test_builtin_image_load_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(i32, i32, i32, tex, 106, 103); //expected-error{{argument to '__builtin_amdgcn_image_load_2d_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_2d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_2d_v4f16_i32' must be a constant integer}} +} + + +float test_builtin_image_load_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_2darray_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_2darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f16_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_2darray_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f32_i32(i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_1d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f16_i32(100, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_1d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_1darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f16_i32(100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_1darray_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_3d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f16_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_3d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f32_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_cube_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_cube_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f32_i32(i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f32_i32(i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f16_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1darray_v4f16_i32' must be a constant integer}} +} + +float test_builtin_image_load_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_f32_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2d_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2d_v4f16_i32' must be a constant integer}} +} + +float test_builtin_image_load_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_f32_i32(i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2darray_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f32_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2darray_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f32_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_3d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f16_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_3d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f32_i32(i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_cube_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_cube_v4f16_i32' must be a constant integer}} +} + +float test_builtin_image_sample_2d(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_f32_f32(i32, f32, f32, tex, vec4i32, 0, 106, 103); //expected-error{{argument to '__builtin_amdgcn_image_sample_2d_f32_f32' must be a constant integer}} +} +float4 test_builtin_image_sample_2d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_2d_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_2d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_2d_v4f16_f32' must be a constant integer}} +} + +float test_builtin_image_sample_2darray(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_2darray_f32_f32' must be a constant integer}} +} +float4 test_builtin_image_sample_2darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_2darray_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_2darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_2darray_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_1d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f32_f32(i32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_1d_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_1d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f16_f32(100, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_1d_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_1darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_1darray_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_1darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f16_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_1darray_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_3d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_3d_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_3d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_3d_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_cube_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f32_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_cube_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_cube_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_cube_v4f16_f32' must be a constant integer}} +} + diff --git a/clang/test/SemaOpenCL/builtins-image-load-param-gfx942-err.cl b/clang/test/SemaOpenCL/builtins-image-load-param-gfx942-err.cl new file mode 100644 index 0000000..b878002 --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-load-param-gfx942-err.cl @@ -0,0 +1,219 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx942 -verify -S -o - %s +// REQUIRES: amdgpu-registered-target + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +float test_builtin_image_load_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(i32, i32, i32, tex, 106, 103); //expected-error{{'test_builtin_image_load_2d' needs target feature image-insts}} +} +float4 test_builtin_image_load_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_2d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_2d_2' needs target feature image-insts}} +} + + +float test_builtin_image_load_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_2darray' needs target feature image-insts}} +} +float4 test_builtin_image_load_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_2darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f16_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_2darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f32_i32(i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_1d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f16_i32(100, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_1d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_1darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f16_i32(100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_1darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_3d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f16_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_3d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f32_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_cube_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_cube_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f32_i32(i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_1d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_1d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f32_i32(i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_1darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f16_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_1darray_2' needs target feature image-insts}} +} + +float test_builtin_image_load_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_f32_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2d' needs target feature image-insts}} +} +float4 test_builtin_image_load_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_mip_2d_2' needs target feature image-insts}} +} + +float test_builtin_image_load_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_f32_i32(i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_mip_2darray' needs target feature image-insts}} +} +float4 test_builtin_image_load_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f32_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f32_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_3d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f16_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_3d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f32_i32(i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_cube_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_cube_2' needs target feature image-insts}} +} + +float test_builtin_image_load_2d_gfx(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(12, i32, i32, tex, 106, 103); //expected-error{{'test_builtin_image_load_2d_gfx' needs target feature image-insts}} +} +float4 test_builtin_image_load_2d_gfx_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_2d_gfx_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_2d_gfx_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_2d_gfx_2' needs target feature image-insts}} +} + +float test_builtin_image_sample_2d(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_f32_f32(i32, f32, f32, tex, vec4i32, 0, 106, 103); //expected-error{{'test_builtin_image_sample_2d' needs target feature image-insts}} +} +float4 test_builtin_image_sample_2d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_2d_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_2d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_2d_2' needs target feature image-insts}} +} + +float test_builtin_image_sample_2darray(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_2darray' needs target feature image-insts}} +} +float4 test_builtin_image_sample_2darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_2darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_2darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_2darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_1d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f32_f32(i32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_1d_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_1d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f16_f32(100, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_1d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_1darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_1darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_1darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f16_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_1darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_3d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_3d_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_3d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_3d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_cube_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f32_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_cube_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_cube_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_cube_2' needs target feature image-insts}} +} + +float test_builtin_image_sample_2d_gfx(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_2d_gfx' needs target feature image-insts}} +} +float4 test_builtin_image_sample_2d_gfx_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_2d_gfx_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_2d_gfx_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_2d_gfx_2' needs target feature image-insts}} +} diff --git a/clang/test/SemaOpenCL/builtins-image-store-param-gfx1100-err.cl b/clang/test/SemaOpenCL/builtins-image-store-param-gfx1100-err.cl new file mode 100644 index 0000000..4f6347e --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-store-param-gfx1100-err.cl @@ -0,0 +1,129 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1100 -S -verify=expected -o - %s +// REQUIRES: amdgpu-registered-target + +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +void test_builtin_image_store_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_f32_i32(f32, i32, i32, i32, tex, 106, 103); //expected-error{{argument to '__builtin_amdgcn_image_store_2d_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_2d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_2d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_f32_i32(f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_2darray_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_2darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_2darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f32_i32(v4f32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_1d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f16_i32(v4f16, 100, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_1d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_1darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f16_i32(v4f16, 100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_1darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_3d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_3d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f32_i32(v4f32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_cube_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_cube_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f32_i32(v4f32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f32_i32(v4f32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_f32_i32(f32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2d_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_f32_i32(f32, i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2darray_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_3d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f16_i32(v4f16, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_3d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_cube_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_cube_v4f16_i32' must be a constant integer}} +} diff --git a/clang/test/SemaOpenCL/builtins-image-store-param-gfx942-err.cl b/clang/test/SemaOpenCL/builtins-image-store-param-gfx942-err.cl new file mode 100644 index 0000000..d0085e5 --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-store-param-gfx942-err.cl @@ -0,0 +1,129 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx942 -S -verify -o - %s +// REQUIRES: amdgpu-registered-target + +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +void test_builtin_image_store_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_f32_i32(f32, i32, i32, i32, tex, 106, 103); //expected-error{{'test_builtin_image_store_2d' needs target feature image-insts}} +} +void test_builtin_image_store_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_2d_1' needs target feature image-insts}} +} +void test_builtin_image_store_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_2d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_f32_i32(f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_2darray' needs target feature image-insts}} +} +void test_builtin_image_store_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_2darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_2darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f32_i32(v4f32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_1d_1' needs target feature image-insts}} +} +void test_builtin_image_store_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f16_i32(v4f16, 100, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_1d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_1darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f16_i32(v4f16, 100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_1darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_3d_1' needs target feature image-insts}} +} +void test_builtin_image_store_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_3d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f32_i32(v4f32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_cube_1' needs target feature image-insts}} +} +void test_builtin_image_store_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_cube_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f32_i32(v4f32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_1d_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_1d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f32_i32(v4f32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_1darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_1darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_f32_i32(f32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2d' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2d_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_mip_2d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_f32_i32(f32, i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_mip_2darray' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_3d_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f16_i32(v4f16, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_3d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_cube_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_cube_2' needs target feature image-insts}} +} diff --git a/clang/unittests/Analysis/LifetimeSafetyTest.cpp b/clang/unittests/Analysis/LifetimeSafetyTest.cpp index 169b2d2..0c05184 100644 --- a/clang/unittests/Analysis/LifetimeSafetyTest.cpp +++ b/clang/unittests/Analysis/LifetimeSafetyTest.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "clang/Analysis/Analyses/LifetimeSafety.h" +#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h" #include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/Testing/TestAST.h" @@ -63,7 +63,7 @@ public: Analysis = std::make_unique<LifetimeSafetyAnalysis>(*AnalysisCtx, nullptr); Analysis->run(); - AnnotationToPointMap = Analysis->getTestPoints(); + AnnotationToPointMap = Analysis->getFactManager().getTestPoints(); } LifetimeSafetyAnalysis &getAnalysis() { return *Analysis; } @@ -98,10 +98,11 @@ public: auto *VD = findDecl<ValueDecl>(VarName); if (!VD) return std::nullopt; - auto OID = Analysis.getOriginIDForDecl(VD); - if (!OID) - ADD_FAILURE() << "Origin for '" << VarName << "' not found."; - return OID; + // This assumes the OriginManager's `get` can find an existing origin. + // We might need a `find` method on OriginManager to avoid `getOrCreate` + // logic in a const-query context if that becomes an issue. + return const_cast<OriginManager &>(Analysis.getFactManager().getOriginMgr()) + .get(*VD); } std::vector<LoanID> getLoansForVar(llvm::StringRef VarName) { @@ -110,7 +111,10 @@ public: ADD_FAILURE() << "Failed to find VarDecl for '" << VarName << "'"; return {}; } - std::vector<LoanID> LID = Analysis.getLoanIDForVar(VD); + std::vector<LoanID> LID; + for (const Loan &L : Analysis.getFactManager().getLoanMgr().getLoans()) + if (L.Path.D == VD) + LID.push_back(L.ID); if (LID.empty()) { ADD_FAILURE() << "Loan for '" << VarName << "' not found."; return {}; @@ -123,7 +127,7 @@ public: ProgramPoint PP = Runner.getProgramPoint(Annotation); if (!PP) return std::nullopt; - return Analysis.getLoansAtPoint(OID, PP); + return Analysis.getLoanPropagation().getLoans(OID, PP); } std::optional<std::vector<std::pair<OriginID, LivenessKind>>> @@ -131,7 +135,10 @@ public: ProgramPoint PP = Runner.getProgramPoint(Annotation); if (!PP) return std::nullopt; - return Analysis.getLiveOriginsAtPoint(PP); + std::vector<std::pair<OriginID, LivenessKind>> Result; + for (auto &[OID, Info] : Analysis.getLiveOrigins().getLiveOriginsAt(PP)) + Result.push_back({OID, Info.Kind}); + return Result; } private: diff --git a/clang/utils/TableGen/SveEmitter.cpp b/clang/utils/TableGen/SveEmitter.cpp index 553c7a3..b1e94e0 100644 --- a/clang/utils/TableGen/SveEmitter.cpp +++ b/clang/utils/TableGen/SveEmitter.cpp @@ -994,8 +994,29 @@ Intrinsic::Intrinsic(StringRef Name, StringRef Proto, uint64_t MergeTy, auto FormatGuard = [](StringRef Guard, StringRef Base) -> std::string { if (Guard.empty() || Guard == Base) return Guard.str(); - if (Guard.contains('|')) - return Base.str() + ",(" + Guard.str() + ")"; + + unsigned Depth = 0; + for (auto &C : Guard) { + switch (C) { + default: + break; + case '|': + if (Depth == 0) + // Group top-level ORs before ANDing with the base feature. + return Base.str() + ",(" + Guard.str() + ")"; + break; + case '(': + ++Depth; + break; + case ')': + if (Depth == 0) + llvm_unreachable("Mismatched parentheses!"); + + --Depth; + break; + } + } + return Base.str() + "," + Guard.str(); }; diff --git a/clang/www/c_status.html b/clang/www/c_status.html index 380f664..a6bcd4c 100644 --- a/clang/www/c_status.html +++ b/clang/www/c_status.html @@ -339,7 +339,7 @@ conformance.</p> <tr> <td>Earthly Demon XV: Definition of Main</td> <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3623.pdf">N3623</a></td> - <td class="unknown" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> <tr> <td>static_assert without UB</td> @@ -359,17 +359,7 @@ conformance.</p> <tr> <td>Member access of an incomplete object</td> <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3532.pdf">N3532</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> - <tr> - <td>Representation of Pointers and nullptr_t</td> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3563.pdf">N3563</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> - <tr> - <td>Classification of the register storage-class specifier</td> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3544.txt">N3544</a></td> - <td class="unknown" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> </table> </details> diff --git a/flang/include/flang/Optimizer/Builder/HLFIRTools.h b/flang/include/flang/Optimizer/Builder/HLFIRTools.h index 190f2ea..f96d222 100644 --- a/flang/include/flang/Optimizer/Builder/HLFIRTools.h +++ b/flang/include/flang/Optimizer/Builder/HLFIRTools.h @@ -485,9 +485,18 @@ hlfir::ElementalOp cloneToElementalOp(mlir::Location loc, /// would be incorrect. bool elementalOpMustProduceTemp(hlfir::ElementalOp elemental); -std::pair<hlfir::Entity, mlir::Value> -createTempFromMold(mlir::Location loc, fir::FirOpBuilder &builder, - hlfir::Entity mold); +/// Create a new temporary based on the provided \p mold entity. +/// +/// The returned temporary has the same element type, shape and type parameters +/// as the mold. When possible, the storage is stack-allocated; otherwise it is +/// heap-allocated (for instance for arrays with dynamic shape or polymorphic +/// cases). The bool result indicates whether heap allocation was used. +/// +/// If the returned bool is true, callers are responsible for arranging cleanup +/// (e.g., generating destruction/deallocation code at an appropriate point). +std::pair<hlfir::Entity, bool> createTempFromMold(mlir::Location loc, + fir::FirOpBuilder &builder, + hlfir::Entity mold); // TODO: this does not support polymorphic molds hlfir::Entity createStackTempFromMold(mlir::Location loc, diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp index 50a687c..68adf34 100644 --- a/flang/lib/Lower/Bridge.cpp +++ b/flang/lib/Lower/Bridge.cpp @@ -5056,8 +5056,7 @@ private: hlfir::Entity entity{baseValue}; auto [temp, cleanup] = hlfir::createTempFromMold(loc, builder, entity); - auto needCleanup = fir::getIntIfConstant(cleanup); - if (needCleanup && *needCleanup) { + if (cleanup) { if (auto declareOp = mlir::dyn_cast<hlfir::DeclareOp>(temp.getDefiningOp())) temps.push_back(declareOp.getMemref()); diff --git a/flang/lib/Lower/Support/PrivateReductionUtils.cpp b/flang/lib/Lower/Support/PrivateReductionUtils.cpp index 1b09801..d433ce3 100644 --- a/flang/lib/Lower/Support/PrivateReductionUtils.cpp +++ b/flang/lib/Lower/Support/PrivateReductionUtils.cpp @@ -516,15 +516,10 @@ void PopulateInitAndCleanupRegionsHelper::initAndCleanupBoxedArray( return createStackTempFromMold(loc, builder, source); auto [temp, needsDealloc] = createTempFromMold(loc, builder, source); - // if needsDealloc isn't statically false, add cleanup region. Always + // if needsDealloc, add cleanup region. Always // do this for allocatable boxes because they might have been re-allocated // in the body of the loop/parallel region - - std::optional<int64_t> cstNeedsDealloc = - fir::getIntIfConstant(needsDealloc); - assert(cstNeedsDealloc.has_value() && - "createTempFromMold decides this statically"); - if (cstNeedsDealloc.has_value() && *cstNeedsDealloc != false) { + if (needsDealloc) { mlir::OpBuilder::InsertionGuard guard(builder); createCleanupRegion(converter, loc, argType, cleanupRegion, sym, isDoConcurrent); diff --git a/flang/lib/Optimizer/Builder/HLFIRTools.cpp b/flang/lib/Optimizer/Builder/HLFIRTools.cpp index dbfcae1..93dfc57 100644 --- a/flang/lib/Optimizer/Builder/HLFIRTools.cpp +++ b/flang/lib/Optimizer/Builder/HLFIRTools.cpp @@ -1392,7 +1392,7 @@ bool hlfir::elementalOpMustProduceTemp(hlfir::ElementalOp elemental) { return false; } -std::pair<hlfir::Entity, mlir::Value> +std::pair<hlfir::Entity, bool> hlfir::createTempFromMold(mlir::Location loc, fir::FirOpBuilder &builder, hlfir::Entity mold) { assert(!mold.isAssumedRank() && @@ -1425,7 +1425,7 @@ hlfir::createTempFromMold(mlir::Location loc, fir::FirOpBuilder &builder, loc, mold.getElementOrSequenceType(), shape, extents, lenParams, genTempDeclareOp, mold.isPolymorphic() ? mold.getBase() : nullptr, useStack, tmpName); - return {hlfir::Entity{base}, builder.createBool(loc, isHeapAlloc)}; + return {hlfir::Entity{base}, isHeapAlloc}; } hlfir::Entity hlfir::createStackTempFromMold(mlir::Location loc, diff --git a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp index 1c77636..53ff13f 100644 --- a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp +++ b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp @@ -136,12 +136,12 @@ createArrayTemp(mlir::Location loc, fir::FirOpBuilder &builder, static mlir::Value copyInTempAndPackage(mlir::Location loc, fir::FirOpBuilder &builder, hlfir::Entity source) { - auto [temp, cleanup] = hlfir::createTempFromMold(loc, builder, source); + auto [temp, mustFree] = hlfir::createTempFromMold(loc, builder, source); assert(!temp.isAllocatable() && "expect temp to already be allocated"); hlfir::AssignOp::create(builder, loc, source, temp, /*realloc=*/false, /*keep_lhs_length_if_realloc=*/false, /*temporary_lhs=*/true); - return packageBufferizedExpr(loc, builder, temp, cleanup); + return packageBufferizedExpr(loc, builder, temp, mustFree); } struct AsExprOpConversion : public mlir::OpConversionPattern<hlfir::AsExprOp> { diff --git a/flang/test/HLFIR/as_expr-codegen.fir b/flang/test/HLFIR/as_expr-codegen.fir index e4dd2a9..762f7da5 100644 --- a/flang/test/HLFIR/as_expr-codegen.fir +++ b/flang/test/HLFIR/as_expr-codegen.fir @@ -13,8 +13,8 @@ func.func @char_expr(%addr: !fir.ref<!fir.char<1,?>>, %len: index) { // CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[VAL_0]] typeparams %[[VAL_1]] {uniq_name = "c"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>) // CHECK: %[[VAL_3:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_1]] : index) {bindc_name = ".tmp"} // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] typeparams %[[VAL_1]] {uniq_name = ".tmp"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>) -// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_2]]#0 to %[[VAL_4]]#0 temporary_lhs : !fir.boxchar<1>, !fir.boxchar<1> +// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: %[[VAL_6:.*]] = fir.undefined tuple<!fir.boxchar<1>, i1> // CHECK: %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_5]], [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1> // CHECK: %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_4]]#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1> @@ -30,8 +30,8 @@ func.func @char_expr_2(%addr: !fir.ref<!fir.char<1,10>>, %len: index) { // CHECK: %[[VAL_2:.*]] = fir.alloca !fir.char<1,10> {bindc_name = ".tmp"} // CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0]] typeparams %[[VAL_1]] {uniq_name = "c"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_2]] typeparams %[[VAL_1]] {uniq_name = ".tmp"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>) -// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_3]]#0 to %[[VAL_4]]#0 temporary_lhs : !fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>> +// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: %[[VAL_6:.*]] = fir.undefined tuple<!fir.ref<!fir.char<1,10>>, i1> // CHECK: %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_5]], [1 : index] : (tuple<!fir.ref<!fir.char<1,10>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1,10>>, i1> // CHECK: %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_4]]#0, [0 : index] : (tuple<!fir.ref<!fir.char<1,10>>, i1>, !fir.ref<!fir.char<1,10>>) -> tuple<!fir.ref<!fir.char<1,10>>, i1> @@ -47,8 +47,8 @@ func.func @shape_from_type(%arg0 : !fir.ref<!fir.array<10x20xi32>>) { // CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_4:.*]] = fir.allocmem !fir.array<10x20xi32> {bindc_name = ".tmp", uniq_name = ""} // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_3]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<10x20xi32>>, !fir.shape<2>) -> (!fir.heap<!fir.array<10x20xi32>>, !fir.heap<!fir.array<10x20xi32>>) -// CHECK: %[[VAL_5:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_6]]#0 temporary_lhs : !fir.ref<!fir.array<10x20xi32>>, !fir.heap<!fir.array<10x20xi32>> +// CHECK: %[[VAL_5:.*]] = arith.constant true // CHECK: %[[VAL_7:.*]] = fir.undefined tuple<!fir.heap<!fir.array<10x20xi32>>, i1> // CHECK: %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_5]], [1 : index] : (tuple<!fir.heap<!fir.array<10x20xi32>>, i1>, i1) -> tuple<!fir.heap<!fir.array<10x20xi32>>, i1> // CHECK: %[[VAL_9:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_6]]#0, [0 : index] : (tuple<!fir.heap<!fir.array<10x20xi32>>, i1>, !fir.heap<!fir.array<10x20xi32>>) -> tuple<!fir.heap<!fir.array<10x20xi32>>, i1> @@ -66,8 +66,8 @@ func.func @shape_from_box(%arg0 : !fir.box<!fir.array<10x?xi32>>) { // CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_1]], %[[VAL_3]]#1 : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_5:.*]] = fir.allocmem !fir.array<10x?xi32>, %[[VAL_3]]#1 {bindc_name = ".tmp", uniq_name = ""} // CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_4]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<10x?xi32>>, !fir.shape<2>) -> (!fir.box<!fir.array<10x?xi32>>, !fir.heap<!fir.array<10x?xi32>>) -// CHECK: %[[VAL_6:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_7]]#0 temporary_lhs : !fir.box<!fir.array<10x?xi32>>, !fir.box<!fir.array<10x?xi32>> +// CHECK: %[[VAL_6:.*]] = arith.constant true // CHECK: %[[VAL_8:.*]] = fir.undefined tuple<!fir.box<!fir.array<10x?xi32>>, i1> // CHECK: %[[VAL_9:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_6]], [1 : index] : (tuple<!fir.box<!fir.array<10x?xi32>>, i1>, i1) -> tuple<!fir.box<!fir.array<10x?xi32>>, i1> // CHECK: %[[VAL_10:.*]] = fir.insert_value %[[VAL_9]], %[[VAL_7]]#0, [0 : index] : (tuple<!fir.box<!fir.array<10x?xi32>>, i1>, !fir.box<!fir.array<10x?xi32>>) -> tuple<!fir.box<!fir.array<10x?xi32>>, i1> diff --git a/flang/test/HLFIR/associate-codegen.fir b/flang/test/HLFIR/associate-codegen.fir index 5d0d678..b596543 100644 --- a/flang/test/HLFIR/associate-codegen.fir +++ b/flang/test/HLFIR/associate-codegen.fir @@ -259,8 +259,8 @@ func.func @test_multiple_associations(%arg0: !hlfir.expr<1x2xi32>) { // CHECK: %[[VAL_6:.*]] = arith.constant 2 : index // CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array<1x2xi32> {bindc_name = ".tmp", uniq_name = ""} // CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_7]](%[[VAL_4]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<1x2xi32>>, !fir.shape<2>) -> (!fir.heap<!fir.array<1x2xi32>>, !fir.heap<!fir.array<1x2xi32>>) -// CHECK: %[[VAL_8:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_9]]#0 temporary_lhs : !hlfir.expr<1x2xi32>, !fir.heap<!fir.array<1x2xi32>> +// CHECK: %[[VAL_8:.*]] = arith.constant true // CHECK: %[[VAL_10:.*]] = fir.undefined tuple<!fir.heap<!fir.array<1x2xi32>>, i1> // CHECK: %[[VAL_11:.*]] = fir.insert_value %[[VAL_10]], %[[VAL_8]], [1 : index] : (tuple<!fir.heap<!fir.array<1x2xi32>>, i1>, i1) -> tuple<!fir.heap<!fir.array<1x2xi32>>, i1> // CHECK: %[[VAL_12:.*]] = fir.insert_value %[[VAL_11]], %[[VAL_9]]#0, [0 : index] : (tuple<!fir.heap<!fir.array<1x2xi32>>, i1>, !fir.heap<!fir.array<1x2xi32>>) -> tuple<!fir.heap<!fir.array<1x2xi32>>, i1> @@ -272,8 +272,8 @@ func.func @test_multiple_associations(%arg0: !hlfir.expr<1x2xi32>) { // CHECK: %[[VAL_17:.*]] = arith.constant 2 : index // CHECK: %[[VAL_18:.*]] = fir.allocmem !fir.array<1x2xi32> {bindc_name = ".tmp", uniq_name = ""} // CHECK: %[[VAL_20:.*]]:2 = hlfir.declare %[[VAL_18]](%[[VAL_15]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<1x2xi32>>, !fir.shape<2>) -> (!fir.heap<!fir.array<1x2xi32>>, !fir.heap<!fir.array<1x2xi32>>) -// CHECK: %[[VAL_19:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_20]]#0 temporary_lhs : !hlfir.expr<1x2xi32>, !fir.heap<!fir.array<1x2xi32>> +// CHECK: %[[VAL_19:.*]] = arith.constant true // CHECK: %[[VAL_21:.*]] = fir.undefined tuple<!fir.heap<!fir.array<1x2xi32>>, i1> // CHECK: %[[VAL_22:.*]] = fir.insert_value %[[VAL_21]], %[[VAL_19]], [1 : index] : (tuple<!fir.heap<!fir.array<1x2xi32>>, i1>, i1) -> tuple<!fir.heap<!fir.array<1x2xi32>>, i1> // CHECK: %[[VAL_23:.*]] = fir.insert_value %[[VAL_22]], %[[VAL_20]]#0, [0 : index] : (tuple<!fir.heap<!fir.array<1x2xi32>>, i1>, !fir.heap<!fir.array<1x2xi32>>) -> tuple<!fir.heap<!fir.array<1x2xi32>>, i1> @@ -303,8 +303,8 @@ func.func @test_get_length(%arg0: !fir.ref<!fir.char<1,2>>) { // CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<1,2> {bindc_name = ".tmp"} // CHECK: %[[VAL_2:.*]] = arith.constant 2 : index // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_1]] typeparams %[[VAL_2]] {uniq_name = ".tmp"} : (!fir.ref<!fir.char<1,2>>, index) -> (!fir.ref<!fir.char<1,2>>, !fir.ref<!fir.char<1,2>>) -// CHECK: %[[VAL_3:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_4]]#0 temporary_lhs : !fir.ref<!fir.char<1,2>>, !fir.ref<!fir.char<1,2>> +// CHECK: %[[VAL_3:.*]] = arith.constant false // CHECK: %[[VAL_5:.*]] = fir.undefined tuple<!fir.ref<!fir.char<1,2>>, i1> // CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_3]], [1 : index] : (tuple<!fir.ref<!fir.char<1,2>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1,2>>, i1> // CHECK: %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_4]]#0, [0 : index] : (tuple<!fir.ref<!fir.char<1,2>>, i1>, !fir.ref<!fir.char<1,2>>) -> tuple<!fir.ref<!fir.char<1,2>>, i1> @@ -355,8 +355,8 @@ func.func @_QPtest_multiple_expr_uses_inside_elemental() { // CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_9]] step %[[VAL_14]] unordered { // CHECK: %[[VAL_16:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_4]] : index) {bindc_name = ".tmp"} // CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_16]] typeparams %[[VAL_4]] {uniq_name = ".tmp"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>) -// CHECK: %[[VAL_17:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_5]]#0 to %[[VAL_18]]#0 temporary_lhs : !fir.boxchar<1>, !fir.boxchar<1> +// CHECK: %[[VAL_17:.*]] = arith.constant false // CHECK: %[[VAL_19:.*]] = fir.undefined tuple<!fir.boxchar<1>, i1> // CHECK: %[[VAL_20:.*]] = fir.insert_value %[[VAL_19]], %[[VAL_17]], [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1> // CHECK: %[[VAL_21:.*]] = fir.insert_value %[[VAL_20]], %[[VAL_18]]#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1> @@ -407,8 +407,8 @@ func.func @_QPtest_multitple_associates_for_same_expr() { // CHECK: %[[VAL_12:.*]] = fir.insert_value %[[VAL_11]], %[[VAL_4]]#0, [0 : index] : (tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1>, !fir.heap<!fir.array<10x!fir.char<1>>>) -> tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> // CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.array<10x!fir.char<1>> {bindc_name = ".tmp", uniq_name = ""} // CHECK: %[[VAL_15:.*]]:2 = hlfir.declare %[[VAL_13]](%[[VAL_2]]) typeparams %[[VAL_0]] {uniq_name = ".tmp"} : (!fir.heap<!fir.array<10x!fir.char<1>>>, !fir.shape<1>, index) -> (!fir.heap<!fir.array<10x!fir.char<1>>>, !fir.heap<!fir.array<10x!fir.char<1>>>) -// CHECK: %[[VAL_14:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_15]]#0 temporary_lhs : !fir.heap<!fir.array<10x!fir.char<1>>>, !fir.heap<!fir.array<10x!fir.char<1>>> +// CHECK: %[[VAL_14:.*]] = arith.constant true // CHECK: %[[VAL_16:.*]] = fir.undefined tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> // CHECK: %[[VAL_17:.*]] = fir.insert_value %[[VAL_16]], %[[VAL_14]], [1 : index] : (tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1>, i1) -> tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> // CHECK: %[[VAL_18:.*]] = fir.insert_value %[[VAL_17]], %[[VAL_15]]#0, [0 : index] : (tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1>, !fir.heap<!fir.array<10x!fir.char<1>>>) -> tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> @@ -418,8 +418,8 @@ func.func @_QPtest_multitple_associates_for_same_expr() { // CHECK: fir.freemem %[[VAL_21]] : !fir.heap<!fir.array<10x!fir.char<1>>> // CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<10x!fir.char<1>> {bindc_name = ".tmp", uniq_name = ""} // CHECK: %[[VAL_24:.*]]:2 = hlfir.declare %[[VAL_22]](%[[VAL_2]]) typeparams %[[VAL_0]] {uniq_name = ".tmp"} : (!fir.heap<!fir.array<10x!fir.char<1>>>, !fir.shape<1>, index) -> (!fir.heap<!fir.array<10x!fir.char<1>>>, !fir.heap<!fir.array<10x!fir.char<1>>>) -// CHECK: %[[VAL_23:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_24]]#0 temporary_lhs : !fir.heap<!fir.array<10x!fir.char<1>>>, !fir.heap<!fir.array<10x!fir.char<1>>> +// CHECK: %[[VAL_23:.*]] = arith.constant true // CHECK: %[[VAL_25:.*]] = fir.undefined tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> // CHECK: %[[VAL_26:.*]] = fir.insert_value %[[VAL_25]], %[[VAL_23]], [1 : index] : (tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1>, i1) -> tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> // CHECK: %[[VAL_27:.*]] = fir.insert_value %[[VAL_26]], %[[VAL_24]]#0, [0 : index] : (tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1>, !fir.heap<!fir.array<10x!fir.char<1>>>) -> tuple<!fir.heap<!fir.array<10x!fir.char<1>>>, i1> diff --git a/flang/test/HLFIR/bufferize-poly-expr.fir b/flang/test/HLFIR/bufferize-poly-expr.fir index 54cdfa3..2a448ee 100644 --- a/flang/test/HLFIR/bufferize-poly-expr.fir +++ b/flang/test/HLFIR/bufferize-poly-expr.fir @@ -27,8 +27,8 @@ func.func @test_poly_expr_without_associate() { // CHECK: %[[VAL_16:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_13]], %[[VAL_14]], %[[VAL_11]], %[[VAL_12:.*]], {{.*}} // CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.class<!fir.heap<!fir.type<_QFtestTt{c:i32}>>>> // CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_17]] {uniq_name = ".tmp"} : (!fir.class<!fir.heap<!fir.type<_QFtestTt{c:i32}>>>) -> (!fir.class<!fir.type<_QFtestTt{c:i32}>>, !fir.class<!fir.type<_QFtestTt{c:i32}>>) -// CHECK: %[[VAL_19:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_18]]#0 temporary_lhs : !fir.class<!fir.type<_QFtestTt{c:i32}>>, !fir.class<!fir.type<_QFtestTt{c:i32}>> +// CHECK: %[[VAL_19:.*]] = arith.constant true // CHECK: %[[VAL_20:.*]] = fir.undefined tuple<!fir.class<!fir.type<_QFtestTt{c:i32}>>, i1> // CHECK: %[[VAL_21:.*]] = fir.insert_value %[[VAL_20]], %[[VAL_19]], [1 : index] : (tuple<!fir.class<!fir.type<_QFtestTt{c:i32}>>, i1>, i1) -> tuple<!fir.class<!fir.type<_QFtestTt{c:i32}>>, i1> // CHECK: %[[VAL_22:.*]] = fir.insert_value %[[VAL_21]], %[[VAL_18]]#0, [0 : index] : (tuple<!fir.class<!fir.type<_QFtestTt{c:i32}>>, i1>, !fir.class<!fir.type<_QFtestTt{c:i32}>>) -> tuple<!fir.class<!fir.type<_QFtestTt{c:i32}>>, i1> @@ -84,8 +84,8 @@ func.func @test_poly_expr_with_associate(%arg1: !fir.class<!fir.array<3x!fir.typ // CHECK: %[[VAL_19:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_16]], %[[VAL_17]], %[[VAL_14]], %[[VAL_15]], {{.*}} // CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.class<!fir.heap<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>>> // CHECK: %[[VAL_21:.*]]:2 = hlfir.declare %[[VAL_20]] {uniq_name = ".tmp"} : (!fir.class<!fir.heap<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>>) -> (!fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>, !fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>) -// CHECK: %[[VAL_22:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_4]] to %[[VAL_21]]#0 temporary_lhs : !fir.class<!fir.heap<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>>, !fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>> +// CHECK: %[[VAL_22:.*]] = arith.constant true // CHECK: %[[VAL_23:.*]] = fir.undefined tuple<!fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>, i1> // CHECK: %[[VAL_24:.*]] = fir.insert_value %[[VAL_23]], %[[VAL_22]], [1 : index] : (tuple<!fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>, i1>, i1) -> tuple<!fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>, i1> // CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[VAL_21]]#0, [0 : index] : (tuple<!fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>, i1>, !fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>) -> tuple<!fir.class<!fir.array<?x!fir.type<_QMtest_typeTt1{i:i32}>>>, i1> diff --git a/flang/test/HLFIR/element-codegen-issue-118922.fir b/flang/test/HLFIR/element-codegen-issue-118922.fir index da998cc..6c109e1 100644 --- a/flang/test/HLFIR/element-codegen-issue-118922.fir +++ b/flang/test/HLFIR/element-codegen-issue-118922.fir @@ -29,7 +29,6 @@ func.func @_QMmPbug(%val: !fir.char<1>, %var: !fir.ref<!fir.array<10x!fir.char<1 // CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<10x!fir.char<1>> {bindc_name = ".tmp.array", uniq_name = ""} // CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) typeparams %[[VAL_3]] {uniq_name = ".tmp.array"} : (!fir.heap<!fir.array<10x!fir.char<1>>>, !fir.shape<1>, index) -> (!fir.heap<!fir.array<10x!fir.char<1>>>, !fir.heap<!fir.array<10x!fir.char<1>>>) -// CHECK: %[[VAL_8:.*]] = arith.constant true // CHECK: %[[VAL_9:.*]] = arith.constant 1 : index // CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_4]] step %[[VAL_9]] unordered { // CHECK: %[[VAL_11:.*]] = fir.allocmem !fir.char<1> @@ -37,8 +36,8 @@ func.func @_QMmPbug(%val: !fir.char<1>, %var: !fir.ref<!fir.array<10x!fir.char<1 // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (!fir.heap<!fir.char<1>>) -> !fir.ref<!fir.char<1>> // CHECK: %[[VAL_13:.*]] = arith.constant 1 : index // CHECK: %[[VAL_15:.*]]:2 = hlfir.declare %[[VAL_2]] typeparams %[[VAL_13]] {uniq_name = ".tmp"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>) -// CHECK: %[[VAL_14:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_12]] to %[[VAL_15]]#0 temporary_lhs : !fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>> +// CHECK: %[[VAL_14:.*]] = arith.constant false // CHECK: %[[VAL_16:.*]] = fir.undefined tuple<!fir.ref<!fir.char<1>>, i1> // CHECK: %[[VAL_17:.*]] = fir.insert_value %[[VAL_16]], %[[VAL_14]], [1 : index] : (tuple<!fir.ref<!fir.char<1>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1>>, i1> // CHECK: %[[VAL_18:.*]] = fir.insert_value %[[VAL_17]], %[[VAL_15]]#0, [0 : index] : (tuple<!fir.ref<!fir.char<1>>, i1>, !fir.ref<!fir.char<1>>) -> tuple<!fir.ref<!fir.char<1>>, i1> diff --git a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 index 5144b33..f3b9397 100644 --- a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 +++ b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 @@ -70,7 +70,6 @@ end subroutine target_allocatable ! CHECK-NEXT: %[[SHAPE:.*]] = fir.shape %[[BOX_DIMS]]#1 ! CHECK-NEXT: %[[DATA_ALLOC:.*]] = fir.allocmem !fir.array<?xf32>, %[[BOX_DIMS]]#1 ! CHECK-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[DATA_ALLOC:.*]](%[[SHAPE]]) -! CHECK-NEXT: %[[TRUE:.*]] = arith.constant true ! CHECK-NEXT: %[[C0_2:.*]] = arith.constant 0 : index ! CHECK-NEXT: %[[BOX_DIMS_2:.*]]:3 = fir.box_dims %[[MOLD]], %[[C0_2]] ! CHECK-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS_2]]#0, %[[BOX_DIMS_2]]#1 diff --git a/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 b/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 index 8446e99..8ade5cd 100644 --- a/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 +++ b/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 @@ -37,7 +37,6 @@ end subroutine ! CHECK-NEXT: %[[SHAPE:.*]] = fir.shape %[[DIMS]]#1 ! CHECK-NEXT: %[[MEM:.*]] = fir.allocmem !fir.array<?xi32>, %[[DIMS]]#1 ! CHECK-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[MEM]](%[[SHAPE]]) -! CHECK-NEXT: %[[TRUE:.*]] = arith.constant true ! CHECK-NEXT: %[[C0_2:.*]] = arith.constant 0 : index ! CHECK-NEXT: %[[DIMS_2:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0_2]] ! CHECK-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[DIMS_2]]#0, %[[DIMS_2]]#1 diff --git a/flang/test/Lower/OpenMP/delayed-privatization-array.f90 b/flang/test/Lower/OpenMP/delayed-privatization-array.f90 index 0cda254..81df53d 100644 --- a/flang/test/Lower/OpenMP/delayed-privatization-array.f90 +++ b/flang/test/Lower/OpenMP/delayed-privatization-array.f90 @@ -39,7 +39,6 @@ end subroutine ! ONE_DIM-NEXT: %[[SHAPE:.*]] = fir.shape %[[DIMS]]#1 ! ONE_DIM-NEXT: %[[ARRAY_ALLOC:.*]] = fir.allocmem !fir.array<?xi32>, %[[DIMS]]#1 ! ONE_DIM-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[SHAPE]]) -! ONE_DIM-NEXT: %[[TRUE:.*]] = arith.constant true ! ONE_DIM-NEXT: %[[C0_0:.*]] = arith.constant 0 ! ONE_DIM-NEXT: %[[DIMS2:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0_0]] ! ONE_DIM-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[DIMS2]]#0, %[[DIMS2]]#1 @@ -77,7 +76,6 @@ end subroutine ! TWO_DIM-NEXT: %[[SHAPE:.*]] = fir.shape %[[DIMS_0]]#1, %[[DIMS_1]]#1 ! TWO_DIM-NEXT: %[[ARRAY_ALLOC:.*]] = fir.allocmem !fir.array<?x?xi32>, %[[DIMS_0]]#1, %[[DIMS_1]]#1 ! TWO_DIM-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[SHAPE]]) -! TWO_DIM-NEXT: %[[TRUE:.*]] = arith.constant true ! TWO_DIM-NEXT: %[[C0_0:.*]] = arith.constant 0 ! TWO_DIM-NEXT: %[[DIMS2_0:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0_0]] ! TWO_DIM-NEXT: %[[C1_0:.*]] = arith.constant 1 @@ -112,7 +110,6 @@ end program ! ONE_DIM_DEFAULT_LB-NEXT: %[[SHAPE:.*]] = fir.shape %[[C10]] ! ONE_DIM_DEFAULT_LB-NEXT: %[[ARRAY_ALLOC:.*]] = fir.allocmem !fir.array<10xi32> ! ONE_DIM_DEFAULT_LB-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[SHAPE]]) -! ONE_DIM_DEFAULT_LB-NEXT: %[[TRUE:.*]] = arith.constant true ! ONE_DIM_DEFAULT_LB-NEXT: %[[ONE:.*]] = arith.constant 1 : index ! ONE_DIM_DEFAULT_LB-NEXT: %[[TEN:.*]] = arith.constant 10 : index ! ONE_DIM_DEFAULT_LB-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[ONE]], %[[TEN]] diff --git a/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 index 0036670..41c7d69 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 @@ -40,7 +40,6 @@ end program ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_4]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>) -! CHECK: %[[VAL_7:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_2]], %[[C0]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 index ea0aa9e..aa91e1e 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 @@ -24,7 +24,6 @@ end program ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_3]], %[[VAL_4]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<3x2xi32> {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<3x2xi32>>, !fir.shape<2>) -> (!fir.heap<!fir.array<3x2xi32>>, !fir.heap<!fir.array<3x2xi32>>) -! CHECK: %[[VAL_7:.*]] = arith.constant true ! CHECK: %[[VAL_9:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_10:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_9]] : (!fir.box<!fir.array<3x2xi32>>, index) -> (index, index, index) ! CHECK: %[[VAL_11:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array.f90 index d410714..59595de 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array.f90 @@ -28,7 +28,6 @@ end program ! CPU: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CPU: %[[VAL_1:.*]] = fir.allocmem !fir.array<3xi32> {bindc_name = ".tmp", uniq_name = ""} ! CPU: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<3xi32>>, -! CPU: %[[TRUE:.*]] = arith.constant true !fir.shape<1>) -> (!fir.heap<!fir.array<3xi32>>, !fir.heap<!fir.array<3xi32>>) ! CPU: %[[C0:.*]] = arith.constant 0 : index ! CPU: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box<!fir.array<3xi32>>, index) -> (index, index, index) diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 index eb0df2b..14338c6 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 @@ -24,7 +24,6 @@ end program ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<3xi32> ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.heap<!fir.array<3xi32>>, !fir.heap<!fir.array<3xi32>>) -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box<!fir.array<3xi32>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 index 3c1daa0..3634445 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 @@ -41,7 +41,6 @@ end program ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_12]](%[[VAL_11]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>) -! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_15]] : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, index) -> (index, index, index) ! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_16]]#0, %[[VAL_16]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/parallel-reduction3.f90 b/flang/test/Lower/OpenMP/parallel-reduction3.f90 index 69d669a4..9af1837 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction3.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction3.f90 @@ -13,7 +13,6 @@ ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_4]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>) -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_2]], %[[C0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 b/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 index 1049044..8b94d51 100644 --- a/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 +++ b/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 @@ -21,7 +21,6 @@ end subroutine ! CHECK: %[[VAL_6:.*]] = fir.shape %[[VAL_5]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_5]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_7]](%[[VAL_6]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>) -! CHECK: %[[VAL_8:.*]] = arith.constant true ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_10]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index) ! CHECK: %[[VAL_12:.*]] = fir.shape_shift %[[VAL_11]]#0, %[[VAL_11]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 index a02188a..2cd953d 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 @@ -54,7 +54,6 @@ end program ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_12]](%[[VAL_11]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>) -! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_15]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) ! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_16]]#0, %[[VAL_16]]#1 : (index, index) -> !fir.shapeshift<1> @@ -116,7 +115,6 @@ end program ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array<?xi32>, %[[VAL_10]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_12]](%[[VAL_11]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi32>>, !fir.heap<!fir.array<?xi32>>) -! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_15]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index) ! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_16]]#0, %[[VAL_16]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 index d8c5706..209ee9a 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 @@ -34,7 +34,6 @@ end program ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<?xf64>, %[[VAL_4]]#1 {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xf64>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xf64>>, !fir.heap<!fir.array<?xf64>>) -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_2]], %[[C0]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 index b7882bc..afaeba2 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 @@ -25,7 +25,6 @@ end program ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<2xi32> {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2xi32>>, !fir.heap<!fir.array<2xi32>>) -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box<!fir.array<2xi32>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 index 7d90335..25b2e97 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 @@ -25,7 +25,6 @@ end program ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<2xi32> {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2xi32>>, !fir.heap<!fir.array<2xi32>>) -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box<!fir.array<2xi32>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 index 5133db0..edd2bcb 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 @@ -36,7 +36,6 @@ endprogram ! CHECK: %[[VAL_6:.*]] = fir.shape %[[VAL_4]], %[[VAL_5]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array<3x3xf64> {bindc_name = ".tmp", uniq_name = ""} ! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_7]](%[[VAL_6]]) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<3x3xf64>>, !fir.shape<2>) -> (!fir.heap<!fir.array<3x3xf64>>, !fir.heap<!fir.array<3x3xf64>>) -! CHECK: %[[VAL_8:.*]] = arith.constant true ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_10]] : (!fir.box<!fir.array<3x3xf64>>, index) -> (index, index, index) ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index diff --git a/libcxx/utils/libcxx/test/format.py b/libcxx/utils/libcxx/test/format.py index 3fcd250..975209c 100644 --- a/libcxx/utils/libcxx/test/format.py +++ b/libcxx/utils/libcxx/test/format.py @@ -361,7 +361,7 @@ class CxxStandardLibraryTest(lit.formats.FileBasedTest): if "enable-benchmarks=run" in test.config.available_features: steps += ["%dbg(EXECUTED AS) %{exec} %t.exe --benchmark_out=%{temp}/benchmark-result.json --benchmark_out_format=json"] parse_results = os.path.join(LIBCXX_UTILS, 'parse-google-benchmark-results') - steps += [f"{parse_results} %{temp}/benchmark-result.json --output-format=lnt > %{temp}/results.lnt"] + steps += [f"{parse_results} %{{temp}}/benchmark-result.json --output-format=lnt > %{{temp}}/results.lnt"] return self._executeShTest(test, litConfig, steps) elif re.search('[.]gen[.][^.]+$', filename): # This only happens when a generator test is not supported return self._executeShTest(test, litConfig, []) diff --git a/lldb/source/Host/freebsd/Host.cpp b/lldb/source/Host/freebsd/Host.cpp index 14c0e9f..fa7efad 100644 --- a/lldb/source/Host/freebsd/Host.cpp +++ b/lldb/source/Host/freebsd/Host.cpp @@ -14,12 +14,13 @@ #include <sys/sysctl.h> #include <sys/user.h> -#include <machine/elf.h> - #include <cstdio> #include <dlfcn.h> #include <execinfo.h> +#include "llvm/Object/ELF.h" + +#include "lldb/Host/FileSystem.h" #include "lldb/Host/Host.h" #include "lldb/Host/HostInfo.h" #include "lldb/Utility/DataBufferHeap.h" @@ -97,17 +98,33 @@ GetFreeBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr, proc_args.AppendArgument(llvm::StringRef(cstr)); } - return true; -} - -static bool GetFreeBSDProcessCPUType(ProcessInstanceInfo &process_info) { - if (process_info.ProcessIDIsValid()) { - process_info.GetArchitecture() = - HostInfo::GetArchitecture(HostInfo::eArchKindDefault); + auto buffer_sp = FileSystem::Instance().CreateDataBuffer(pathname, 0x20, 0); + if (!buffer_sp) { + process_info.Clear(); return true; } - process_info.GetArchitecture().Clear(); - return false; + uint8_t exe_class = + llvm::object::getElfArchType( + {reinterpret_cast<const char *>(buffer_sp->GetBytes()), + size_t(buffer_sp->GetByteSize())}) + .first; + + switch (exe_class) { + case llvm::ELF::ELFCLASS32: + process_info.SetArchitecture( + HostInfo::GetArchitecture(HostInfo::eArchKind32)); + break; + case llvm::ELF::ELFCLASS64: + process_info.SetArchitecture( + HostInfo::GetArchitecture(HostInfo::eArchKind64)); + break; + case llvm::ELF::ELFCLASSNONE: + process_info.SetArchitecture( + HostInfo::GetArchitecture(HostInfo::eArchKindDefault)); + break; + } + + return true; } static bool GetFreeBSDProcessUserAndGroup(ProcessInstanceInfo &process_info) { @@ -214,7 +231,6 @@ uint32_t Host::FindProcessesImpl(const ProcessInstanceInfoMatch &match_info, // Make sure our info matches before we go fetch the name and cpu type if (match_info_noname.Matches(process_info) && GetFreeBSDProcessArgs(&match_info, process_info)) { - GetFreeBSDProcessCPUType(process_info); if (match_info.Matches(process_info)) process_infos.push_back(process_info); } @@ -228,7 +244,6 @@ bool Host::GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info) { if (GetFreeBSDProcessArgs(NULL, process_info)) { // should use libprocstat instead of going right into sysctl? - GetFreeBSDProcessCPUType(process_info); GetFreeBSDProcessUserAndGroup(process_info); return true; } diff --git a/lldb/test/API/functionalities/unwind/cortex-m-exception/TestCortexMExceptionUnwind.py b/lldb/test/API/functionalities/unwind/cortex-m-exception/TestCortexMExceptionUnwind.py index 768dd6f..ebba4d1 100644 --- a/lldb/test/API/functionalities/unwind/cortex-m-exception/TestCortexMExceptionUnwind.py +++ b/lldb/test/API/functionalities/unwind/cortex-m-exception/TestCortexMExceptionUnwind.py @@ -12,20 +12,6 @@ from lldbsuite.test import lldbutil class TestCortexMExceptionUnwind(TestBase): NO_DEBUG_INFO_TESTCASE = True - # on the lldb-remote-linux-ubuntu CI, the binary.json's triple of - # armv7m-apple is not being set in the Target triple, and we're - # picking the wrong ABI plugin, ABISysV_arm. - # ABISysV_arm::CreateDefaultUnwindPlan() doesn't have a way to detect - # arm/thumb for a stack frame, or even the Target's triple for a - # Cortex-M part that is always thumb. It hardcodes r11 as the frame - # pointer register, which is correct for arm code but not thumb. - # It is never correct # on a Cortex-M target. - # The Darwin ABIMacOSX_arm diverges from AAPCS and always uses r7 for - # the frame pointer -- the thumb convention -- whether executing arm or - # thumb. So its CreateDefaultUnwindPlan picks the correct register for - # the frame pointer, and we can walk the stack. - # ABISysV_arm::CreateDefaultUnwindPlan will only get one frame and - # not be able to continue. @skipIfRemote def test_no_fpu(self): """Test that we can backtrace correctly through an ARM Cortex-M Exception return stack""" @@ -59,10 +45,9 @@ class TestCortexMExceptionUnwind(TestBase): # frames above that. The topmost two stack frames # were not interesting for this test, so I didn't # create symbols for them. - self.assertEqual(thread.GetNumFrames(), 6) + self.assertEqual(thread.GetNumFrames(), 3) stackframe_names = [ "exception_catcher", - "exception_catcher", "exception_thrower", "main", ] diff --git a/lldb/test/API/functionalities/unwind/cortex-m-exception/armv7m-nofpu-exception.yaml b/lldb/test/API/functionalities/unwind/cortex-m-exception/armv7m-nofpu-exception.yaml index 9ce5ff4..0b4e1f8 100644 --- a/lldb/test/API/functionalities/unwind/cortex-m-exception/armv7m-nofpu-exception.yaml +++ b/lldb/test/API/functionalities/unwind/cortex-m-exception/armv7m-nofpu-exception.yaml @@ -2,8 +2,8 @@ cpu: armv7m threads: - regsets: - flavor: gpr - registers: [{name: sp, value: 0x2000fe70}, {name: r7, value: 0x2000fe80}, - {name: pc, value: 0x0020392c}, {name: lr, value: 0x0020392d}] + registers: [{name: sp, value: 0x2000fe88}, {name: r7, value: 0x2000fe88}, + {name: pc, value: 0x00203916}, {name: lr, value: 0x0020392d}] memory-regions: # stack memory fetched via # (lldb) p/x $sp @@ -14,7 +14,7 @@ memory-regions: 0x0000002a, 0x20010e58, 0x00203923, 0x00000001, 0x2000fe88, 0x00203911, 0x2000ffdc, 0xfffffff9, 0x00000102, 0x00000002, 0x000003f0, 0x0000002a, - 0x20012620, 0x00203215, 0x00203366, 0x81000200, + 0x20012620, 0x00203215, 0x00202a92, 0x81000200, 0x00203215, 0x200128b0, 0x0024928d, 0x2000fecc, 0x002491ed, 0x20010e58, 0x20010e4c, 0x2000ffa0, 0x200107a0, 0x0000003c, 0x200116e8, 0x200108b0, @@ -62,3 +62,26 @@ memory-regions: 0x98, 0xae, 0x28, 0x00 ] + # exception_thrower + # (lldb) disass -b -c 12 -n exception_thrower + # 0x202a88 <+0>: 0xb5f0 push {r4, r5, r6, r7, lr} + # 0x202a8a <+2>: 0xaf03 add r7, sp, #0xc + # 0x202a8c <+4>: 0xe92d0f00 push.w {r8, r9, r10, r11} + # 0x202a90 <+8>: 0xb0c3 sub sp, #0x10c + # 0x202a92 <+10>: 0xf7ffffd9 bl 0x202a48 + - addr: 0x202a88 + UInt8: [ + 0xf0, 0xb5, 0x03, 0xaf, 0x2d, 0xe9, 0x00, 0x0f, + 0xc3, 0xb0, 0xff, 0xf7, 0xd9, 0xff, 0xff, 0xf7 + ] + + # main: + # 0x202a7e <+0>: push {r7, lr} + # 0x202a80 <+2>: mov r7, sp + # 0x202a82 <+4>: bl 0x202a88 ; exception_thrower + # 0x202a86 <+8>: nop + - addr: 0x202a7e + UInt8: [ + 0x80, 0xb5, 0x6f, 0x46, 0x00, 0xf0, 0x01, 0xf8, + 0x00, 0xbf + ] diff --git a/lldb/test/API/functionalities/unwind/cortex-m-exception/binary.json b/lldb/test/API/functionalities/unwind/cortex-m-exception/binary.json index 8fcd530..0de0169 100644 --- a/lldb/test/API/functionalities/unwind/cortex-m-exception/binary.json +++ b/lldb/test/API/functionalities/unwind/cortex-m-exception/binary.json @@ -1,5 +1,5 @@ { - "triple": "armv7m-apple", + "triple": "armv7m--", "uuid": "2D157DBA-53C9-3AC7-B5A1-9D336EC831CB", "type": "executable", "sections": [ @@ -28,13 +28,13 @@ { "name": "exception_catcher", "type": "code", - "size": 44, + "size": 32, "address": 2111760 }, { "name": "exception_thrower", "type": "code", - "size": 2652, + "size": 16, "address": 2108040 } ] diff --git a/lldb/test/API/lang/cpp/floating-types-specialization/TestCppFloatingTypesSpecialization.py b/lldb/test/API/lang/cpp/floating-types-specialization/TestCppFloatingTypesSpecialization.py index f4530cd..979391f 100644 --- a/lldb/test/API/lang/cpp/floating-types-specialization/TestCppFloatingTypesSpecialization.py +++ b/lldb/test/API/lang/cpp/floating-types-specialization/TestCppFloatingTypesSpecialization.py @@ -6,6 +6,7 @@ from lldbsuite.test import lldbutil class TestCase(TestBase): + @skipIf(compiler="clang", compiler_version=["<", "17.0"]) def test(self): self.build() lldbutil.run_to_source_breakpoint( diff --git a/llvm/include/llvm/ADT/Bitset.h b/llvm/include/llvm/ADT/Bitset.h index b1e539e..1d4cbf8 100644 --- a/llvm/include/llvm/ADT/Bitset.h +++ b/llvm/include/llvm/ADT/Bitset.h @@ -38,14 +38,27 @@ class Bitset { static constexpr unsigned NumWords = (NumBits + BitwordBits - 1) / BitwordBits; -protected: using StorageType = std::array<BitWord, NumWords>; - -private: StorageType Bits{}; protected: - constexpr Bitset(const StorageType &B) : Bits{B} {} + constexpr Bitset(const std::array<uint64_t, (NumBits + 63) / 64> &B) { + if constexpr (sizeof(BitWord) == sizeof(uint64_t)) { + for (size_t I = 0; I != B.size(); ++I) + Bits[I] = B[I]; + } else { + unsigned BitsToAssign = NumBits; + for (size_t I = 0; I != B.size() && BitsToAssign; ++I) { + uint64_t Elt = B[I]; + // On a 32-bit system the storage type will be 32-bit, so we may only + // need half of a uint64_t. + for (size_t offset = 0; offset != 2 && BitsToAssign; ++offset) { + Bits[2 * I + offset] = static_cast<uint32_t>(Elt >> (32 * offset)); + BitsToAssign = BitsToAssign >= 32 ? BitsToAssign - 32 : 0; + } + } + } + } public: constexpr Bitset() = default; diff --git a/llvm/include/llvm/ADT/ImmutableSet.h b/llvm/include/llvm/ADT/ImmutableSet.h index 017585a4..310539f 100644 --- a/llvm/include/llvm/ADT/ImmutableSet.h +++ b/llvm/include/llvm/ADT/ImmutableSet.h @@ -21,7 +21,9 @@ #include "llvm/ADT/iterator.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/Signals.h" #include <cassert> #include <cstdint> #include <functional> diff --git a/llvm/include/llvm/Analysis/DependenceAnalysis.h b/llvm/include/llvm/Analysis/DependenceAnalysis.h index a2ca695..18a8f8a 100644 --- a/llvm/include/llvm/Analysis/DependenceAnalysis.h +++ b/llvm/include/llvm/Analysis/DependenceAnalysis.h @@ -160,7 +160,7 @@ public: /// getDVEntry - Returns the DV entry associated with a regular or a /// SameSD level - DVEntry getDVEntry(unsigned Level, bool isSameSD) const; + DVEntry getDVEntry(unsigned Level, bool IsSameSD) const; /// getDirection - Returns the direction associated with a particular /// common or SameSD level. @@ -234,7 +234,7 @@ public: /// dumpImp - For debugging purposes. Dumps a dependence to OS with or /// without considering the SameSD levels. - void dumpImp(raw_ostream &OS, bool SameSD = false) const; + void dumpImp(raw_ostream &OS, bool IsSameSD = false) const; protected: Instruction *Src, *Dst; @@ -282,8 +282,8 @@ public: /// getDVEntry - Returns the DV entry associated with a regular or a /// SameSD level. - DVEntry getDVEntry(unsigned Level, bool isSameSD) const { - if (!isSameSD) { + DVEntry getDVEntry(unsigned Level, bool IsSameSD) const { + if (!IsSameSD) { assert(0 < Level && Level <= Levels && "Level out of range"); return DV[Level - 1]; } else { diff --git a/llvm/include/llvm/AsmParser/LLToken.h b/llvm/include/llvm/AsmParser/LLToken.h index d976d40e..6de99fe 100644 --- a/llvm/include/llvm/AsmParser/LLToken.h +++ b/llvm/include/llvm/AsmParser/LLToken.h @@ -488,27 +488,28 @@ enum Kind { SummaryID, // ^42 // String valued tokens (StrVal). - LabelStr, // foo: - GlobalVar, // @foo @"foo" - ComdatVar, // $foo - LocalVar, // %foo %"foo" - MetadataVar, // !foo - StringConstant, // "foo" - DwarfTag, // DW_TAG_foo - DwarfAttEncoding, // DW_ATE_foo - DwarfVirtuality, // DW_VIRTUALITY_foo - DwarfLang, // DW_LANG_foo - DwarfCC, // DW_CC_foo - EmissionKind, // lineTablesOnly - NameTableKind, // GNU - FixedPointKind, // Fixed point - DwarfOp, // DW_OP_foo - DIFlag, // DIFlagFoo - DISPFlag, // DISPFlagFoo - DwarfMacinfo, // DW_MACINFO_foo - ChecksumKind, // CSK_foo - DbgRecordType, // dbg_foo - DwarfEnumKind, // DW_APPLE_ENUM_KIND_foo + LabelStr, // foo: + GlobalVar, // @foo @"foo" + ComdatVar, // $foo + LocalVar, // %foo %"foo" + MetadataVar, // !foo + StringConstant, // "foo" + DwarfTag, // DW_TAG_foo + DwarfAttEncoding, // DW_ATE_foo + DwarfVirtuality, // DW_VIRTUALITY_foo + DwarfLang, // DW_LANG_foo + DwarfSourceLangName, // DW_LNAME_foo + DwarfCC, // DW_CC_foo + EmissionKind, // lineTablesOnly + NameTableKind, // GNU + FixedPointKind, // Fixed point + DwarfOp, // DW_OP_foo + DIFlag, // DIFlagFoo + DISPFlag, // DISPFlagFoo + DwarfMacinfo, // DW_MACINFO_foo + ChecksumKind, // CSK_foo + DbgRecordType, // dbg_foo + DwarfEnumKind, // DW_APPLE_ENUM_KIND_foo // Type valued tokens (TyVal). Type, diff --git a/llvm/include/llvm/CodeGen/SlotIndexes.h b/llvm/include/llvm/CodeGen/SlotIndexes.h index 1e270b4..780bd82 100644 --- a/llvm/include/llvm/CodeGen/SlotIndexes.h +++ b/llvm/include/llvm/CodeGen/SlotIndexes.h @@ -467,16 +467,27 @@ class raw_ostream; return getMBBRange(mbb).first; } - /// Returns the last index in the given basic block number. + /// Returns the index past the last valid index in the given basic block. SlotIndex getMBBEndIdx(unsigned Num) const { return getMBBRange(Num).second; } - /// Returns the last index in the given basic block. + /// Returns the index past the last valid index in the given basic block. SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const { return getMBBRange(mbb).second; } + /// Returns the last valid index in the given basic block. + /// This index corresponds to the dead slot of the last non-debug + /// instruction and can be used to find live-out ranges of the block. Note + /// that getMBBEndIdx returns the start index of the next block, which is + /// also used as the start index for segments with phi-def values. If the + /// basic block doesn't contain any non-debug instructions, this returns + /// the same as getMBBStartIdx.getDeadSlot(). + SlotIndex getMBBLastIdx(const MachineBasicBlock *MBB) const { + return getMBBEndIdx(MBB).getPrevSlot(); + } + /// Iterator over the idx2MBBMap (sorted pairs of slot index of basic block /// begin and basic block) using MBBIndexIterator = SmallVectorImpl<IdxMBBPair>::const_iterator; diff --git a/llvm/include/llvm/IR/ConstantFPRange.h b/llvm/include/llvm/IR/ConstantFPRange.h index 930c6f9..4a54caa 100644 --- a/llvm/include/llvm/IR/ConstantFPRange.h +++ b/llvm/include/llvm/IR/ConstantFPRange.h @@ -200,6 +200,12 @@ public: /// with another range. The resultant range is guaranteed to include the /// elements of both sets, but may contain more. LLVM_ABI ConstantFPRange unionWith(const ConstantFPRange &CR) const; + + /// Calculate absolute value range. + LLVM_ABI ConstantFPRange abs() const; + + /// Calculate range of negated values. + LLVM_ABI ConstantFPRange negate() const; }; inline raw_ostream &operator<<(raw_ostream &OS, const ConstantFPRange &CR) { diff --git a/llvm/include/llvm/IR/PatternMatch.h b/llvm/include/llvm/IR/PatternMatch.h index 2e31fe5..7934277 100644 --- a/llvm/include/llvm/IR/PatternMatch.h +++ b/llvm/include/llvm/IR/PatternMatch.h @@ -2184,6 +2184,18 @@ inline PtrToIntSameSize_match<OpTy> m_PtrToIntSameSize(const DataLayout &DL, return PtrToIntSameSize_match<OpTy>(DL, Op); } +/// Matches PtrToAddr. +template <typename OpTy> +inline CastOperator_match<OpTy, Instruction::PtrToAddr> +m_PtrToAddr(const OpTy &Op) { + return CastOperator_match<OpTy, Instruction::PtrToAddr>(Op); +} + +/// Matches PtrToInt or PtrToAddr. +template <typename OpTy> inline auto m_PtrToIntOrAddr(const OpTy &Op) { + return m_CombineOr(m_PtrToInt(Op), m_PtrToAddr(Op)); +} + /// Matches IntToPtr. template <typename OpTy> inline CastOperator_match<OpTy, Instruction::IntToPtr> diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h index 93183bc..307cc66 100644 --- a/llvm/include/llvm/IR/RuntimeLibcalls.h +++ b/llvm/include/llvm/IR/RuntimeLibcalls.h @@ -15,6 +15,7 @@ #define LLVM_IR_RUNTIME_LIBCALLS_H #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/Bitset.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/StringTable.h" #include "llvm/IR/CallingConv.h" @@ -54,8 +55,22 @@ static inline auto libcall_impls() { static_cast<RTLIB::LibcallImpl>(RTLIB::NumLibcallImpls)); } +/// Manage a bitset representing the list of available libcalls for a module. +class LibcallImplBitset : public Bitset<RTLIB::NumLibcallImpls> { +public: + constexpr LibcallImplBitset() = default; + constexpr LibcallImplBitset( + const std::array<uint64_t, (RTLIB::NumLibcallImpls + 63) / 64> &Src) + : Bitset(Src) {} +}; + /// A simple container for information about the supported runtime calls. struct RuntimeLibcallsInfo { +private: + /// Bitset of libcalls a module may emit a call to. + LibcallImplBitset AvailableLibcallImpls; + +public: explicit RuntimeLibcallsInfo( const Triple &TT, ExceptionHandling ExceptionModel = ExceptionHandling::None, @@ -129,6 +144,14 @@ struct RuntimeLibcallsInfo { return getLibcallName(RTLIB::MEMMOVE); } + bool isAvailable(RTLIB::LibcallImpl Impl) const { + return AvailableLibcallImpls.test(Impl); + } + + void setAvailable(RTLIB::LibcallImpl Impl) { + AvailableLibcallImpls.set(Impl); + } + /// Return the libcall provided by \p Impl static RTLIB::Libcall getLibcallFromImpl(RTLIB::LibcallImpl Impl) { return ImplToLibcall[Impl]; @@ -225,8 +248,7 @@ private: /// Return true if the target has sincosf/sincos/sincosl functions static bool hasSinCos(const Triple &TT) { - return TT.isGNUEnvironment() || TT.isOSFuchsia() || - (TT.isAndroid() && !TT.isAndroidVersionLT(9)); + return TT.isGNUEnvironment() || TT.isOSFuchsia() || TT.isAndroid(); } static bool hasSinCos_f32_f64(const Triple &TT) { diff --git a/llvm/include/llvm/Target/GlobalISel/Combine.td b/llvm/include/llvm/Target/GlobalISel/Combine.td index e2b7a5e..3d21f52 100644 --- a/llvm/include/llvm/Target/GlobalISel/Combine.td +++ b/llvm/include/llvm/Target/GlobalISel/Combine.td @@ -695,6 +695,7 @@ def constant_fold_fabs : constant_fold_unary_fp_op_rule<G_FABS>; def constant_fold_fsqrt : constant_fold_unary_fp_op_rule<G_FSQRT>; def constant_fold_flog2 : constant_fold_unary_fp_op_rule<G_FLOG2>; def constant_fold_fptrunc : constant_fold_unary_fp_op_rule<G_FPTRUNC>; +def constant_fold_fpext : constant_fold_unary_fp_op_rule<G_FPEXT>; // Fold constant zero int to fp conversions. class itof_const_zero_fold_rule<Instruction opcode> : GICombineRule < @@ -713,6 +714,7 @@ def constant_fold_fp_ops : GICombineGroup<[ constant_fold_fsqrt, constant_fold_flog2, constant_fold_fptrunc, + constant_fold_fpext, itof_const_zero_fold_si, itof_const_zero_fold_ui ]>; diff --git a/llvm/include/llvm/Target/TargetSelectionDAG.td b/llvm/include/llvm/Target/TargetSelectionDAG.td index 7bc90d4..774063b 100644 --- a/llvm/include/llvm/Target/TargetSelectionDAG.td +++ b/llvm/include/llvm/Target/TargetSelectionDAG.td @@ -116,7 +116,7 @@ def SDTIntBinOp : SDTypeProfile<1, 2, [ // add, and, or, xor, udiv, etc. SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0> ]>; def SDTIntShiftOp : SDTypeProfile<1, 2, [ // shl, sra, srl - SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisInt<2> + SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisInt<2>, SDTCisSameNumEltsAs<0, 2> ]>; def SDTIntShiftPairOp : SDTypeProfile<2, 3, [ // shl_parts, sra_parts, srl_parts SDTCisInt<0>, SDTCisSameAs<1, 0>, diff --git a/llvm/include/llvm/Transforms/Scalar/GVN.h b/llvm/include/llvm/Transforms/Scalar/GVN.h index 74a4d6c..bc0f108 100644 --- a/llvm/include/llvm/Transforms/Scalar/GVN.h +++ b/llvm/include/llvm/Transforms/Scalar/GVN.h @@ -28,6 +28,7 @@ #include <cstdint> #include <optional> #include <utility> +#include <variant> #include <vector> namespace llvm { @@ -322,11 +323,6 @@ private: }; LeaderMap LeaderTable; - // Block-local map of equivalent values to their leader, does not - // propagate to any successors. Entries added mid-block are applied - // to the remaining instructions in the block. - SmallMapVector<Value *, Value *, 4> ReplaceOperandsWithMap; - // Map the block to reversed postorder traversal number. It is used to // find back edge easily. DenseMap<AssertingVH<BasicBlock>, uint32_t> BlockRPONumber; @@ -402,9 +398,9 @@ private: void verifyRemoved(const Instruction *I) const; bool splitCriticalEdges(); BasicBlock *splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ); - bool replaceOperandsForInBlockEquality(Instruction *I) const; - bool propagateEquality(Value *LHS, Value *RHS, const BasicBlockEdge &Root, - bool DominatesByEdge); + bool + propagateEquality(Value *LHS, Value *RHS, + const std::variant<BasicBlockEdge, Instruction *> &Root); bool processFoldableCondBr(BranchInst *BI); void addDeadBlock(BasicBlock *BB); void assignValNumForDeadCode(); diff --git a/llvm/include/llvm/Transforms/Utils/Local.h b/llvm/include/llvm/Transforms/Utils/Local.h index 3f5f427..9acfd87 100644 --- a/llvm/include/llvm/Transforms/Utils/Local.h +++ b/llvm/include/llvm/Transforms/Utils/Local.h @@ -452,6 +452,11 @@ LLVM_ABI unsigned replaceDominatedUsesWith(Value *From, Value *To, LLVM_ABI unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB); +/// Replace each use of 'From' with 'To' if that use is dominated by the +/// given instruction. Returns the number of replacements made. +LLVM_ABI unsigned replaceDominatedUsesWith(Value *From, Value *To, + DominatorTree &DT, + const Instruction *I); /// Replace each use of 'From' with 'To' if that use is dominated by /// the given edge and the callback ShouldReplace returns true. Returns the /// number of replacements made. @@ -464,6 +469,12 @@ LLVM_ABI unsigned replaceDominatedUsesWithIf( LLVM_ABI unsigned replaceDominatedUsesWithIf( Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB, function_ref<bool(const Use &U, const Value *To)> ShouldReplace); +/// Replace each use of 'From' with 'To' if that use is dominated by +/// the given instruction and the callback ShouldReplace returns true. Returns +/// the number of replacements made. +LLVM_ABI unsigned replaceDominatedUsesWithIf( + Value *From, Value *To, DominatorTree &DT, const Instruction *I, + function_ref<bool(const Use &U, const Value *To)> ShouldReplace); /// Return true if this call calls a gc leaf function. /// diff --git a/llvm/include/llvm/Transforms/Utils/MisExpect.h b/llvm/include/llvm/Transforms/Utils/MisExpect.h index e9fba47..2d35d92 100644 --- a/llvm/include/llvm/Transforms/Utils/MisExpect.h +++ b/llvm/include/llvm/Transforms/Utils/MisExpect.h @@ -22,8 +22,7 @@ #include "llvm/IR/Instructions.h" #include "llvm/IR/LLVMContext.h" -namespace llvm { -namespace misexpect { +namespace llvm::misexpect { /// checkBackendInstrumentation - compares PGO counters to the thresholds used /// for llvm.expect and warns if the PGO counters are outside of the expected @@ -34,8 +33,8 @@ namespace misexpect { /// /// \param I The Instruction being checked /// \param RealWeights A vector of profile weights for each target block -void checkBackendInstrumentation(Instruction &I, - const llvm::ArrayRef<uint32_t> RealWeights); +void checkBackendInstrumentation(const Instruction &I, + ArrayRef<uint32_t> RealWeights); /// checkFrontendInstrumentation - compares PGO counters to the thresholds used /// for llvm.expect and warns if the PGO counters are outside of the expected @@ -48,8 +47,8 @@ void checkBackendInstrumentation(Instruction &I, /// \param I The Instruction being checked /// \param ExpectedWeights A vector of the expected weights for each target /// block, this determines the threshold values used when emitting diagnostics -void checkFrontendInstrumentation(Instruction &I, - const ArrayRef<uint32_t> ExpectedWeights); +void checkFrontendInstrumentation(const Instruction &I, + ArrayRef<uint32_t> ExpectedWeights); /// veryifyMisExpect - compares RealWeights to the thresholds used /// for llvm.expect and warns if the PGO counters are outside of the expected @@ -58,8 +57,8 @@ void checkFrontendInstrumentation(Instruction &I, /// \param I The Instruction being checked /// \param RealWeights A vector of profile weights from the profile data /// \param ExpectedWeights A vector of the weights attatch by llvm.expect -void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, - const ArrayRef<uint32_t> ExpectedWeights); +void verifyMisExpect(const Instruction &I, ArrayRef<uint32_t> RealWeights, + ArrayRef<uint32_t> ExpectedWeights); /// checkExpectAnnotations - compares PGO counters to the thresholds used /// for llvm.expect and warns if the PGO counters are outside of the expected @@ -72,11 +71,10 @@ void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, /// \param I The Instruction being checked /// \param ExistingWeights A vector of profile weights for each target block /// \param IsFrontend A boolean describing if this is Frontend instrumentation -void checkExpectAnnotations(Instruction &I, - const ArrayRef<uint32_t> ExistingWeights, +void checkExpectAnnotations(const Instruction &I, + ArrayRef<uint32_t> ExistingWeights, bool IsFrontend); -} // namespace misexpect -} // namespace llvm +} // namespace llvm::misexpect #endif diff --git a/llvm/lib/Analysis/DependenceAnalysis.cpp b/llvm/lib/Analysis/DependenceAnalysis.cpp index 1f0da8d1..8d20b0e 100644 --- a/llvm/lib/Analysis/DependenceAnalysis.cpp +++ b/llvm/lib/Analysis/DependenceAnalysis.cpp @@ -275,7 +275,7 @@ bool Dependence::isAnti() const { // if no subscript in the source or destination mention the induction // variable associated with the loop at this level. // Leave this out of line, so it will serve as a virtual method anchor -bool Dependence::isScalar(unsigned level, bool isSameSD) const { return false; } +bool Dependence::isScalar(unsigned level, bool IsSameSD) const { return false; } //===----------------------------------------------------------------------===// // FullDependence methods @@ -351,38 +351,38 @@ bool FullDependence::normalize(ScalarEvolution *SE) { // getDirection - Returns the direction associated with a particular common or // SameSD level. -unsigned FullDependence::getDirection(unsigned Level, bool isSameSD) const { - return getDVEntry(Level, isSameSD).Direction; +unsigned FullDependence::getDirection(unsigned Level, bool IsSameSD) const { + return getDVEntry(Level, IsSameSD).Direction; } // Returns the distance (or NULL) associated with a particular common or // SameSD level. -const SCEV *FullDependence::getDistance(unsigned Level, bool isSameSD) const { - return getDVEntry(Level, isSameSD).Distance; +const SCEV *FullDependence::getDistance(unsigned Level, bool IsSameSD) const { + return getDVEntry(Level, IsSameSD).Distance; } // Returns true if a particular regular or SameSD level is scalar; that is, // if no subscript in the source or destination mention the induction variable // associated with the loop at this level. -bool FullDependence::isScalar(unsigned Level, bool isSameSD) const { - return getDVEntry(Level, isSameSD).Scalar; +bool FullDependence::isScalar(unsigned Level, bool IsSameSD) const { + return getDVEntry(Level, IsSameSD).Scalar; } // Returns true if peeling the first iteration from this regular or SameSD // loop level will break this dependence. -bool FullDependence::isPeelFirst(unsigned Level, bool isSameSD) const { - return getDVEntry(Level, isSameSD).PeelFirst; +bool FullDependence::isPeelFirst(unsigned Level, bool IsSameSD) const { + return getDVEntry(Level, IsSameSD).PeelFirst; } // Returns true if peeling the last iteration from this regular or SameSD // loop level will break this dependence. -bool FullDependence::isPeelLast(unsigned Level, bool isSameSD) const { - return getDVEntry(Level, isSameSD).PeelLast; +bool FullDependence::isPeelLast(unsigned Level, bool IsSameSD) const { + return getDVEntry(Level, IsSameSD).PeelLast; } // Returns true if splitting loop will break the dependence. -bool FullDependence::isSplitable(unsigned Level, bool isSameSD) const { - return getDVEntry(Level, isSameSD).Splitable; +bool FullDependence::isSplitable(unsigned Level, bool IsSameSD) const { + return getDVEntry(Level, IsSameSD).Splitable; } // inSameSDLoops - Returns true if this level is an SameSD level, i.e., @@ -691,7 +691,7 @@ void Dependence::dump(raw_ostream &OS) const { dumpImp(OS); unsigned SameSDLevels = getSameSDLevels(); if (SameSDLevels > 0) { - OS << "! / assuming " << SameSDLevels << " loop level(s) fused: "; + OS << " / assuming " << SameSDLevels << " loop level(s) fused: "; dumpImp(OS, true); } } @@ -706,13 +706,13 @@ void Dependence::dump(raw_ostream &OS) const { // For debugging purposes. Dumps a dependence to OS with or without considering // the SameSD levels. -void Dependence::dumpImp(raw_ostream &OS, bool isSameSD) const { +void Dependence::dumpImp(raw_ostream &OS, bool IsSameSD) const { bool Splitable = false; unsigned Levels = getLevels(); unsigned SameSDLevels = getSameSDLevels(); bool OnSameSD = false; unsigned LevelNum = Levels; - if (isSameSD) + if (IsSameSD) LevelNum += SameSDLevels; OS << " ["; for (unsigned II = 1; II <= LevelNum; ++II) { diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp index d1977f0..4e38626 100644 --- a/llvm/lib/Analysis/InstructionSimplify.cpp +++ b/llvm/lib/Analysis/InstructionSimplify.cpp @@ -671,12 +671,12 @@ Value *llvm::simplifyAddInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, /// This is very similar to stripAndAccumulateConstantOffsets(), except it /// normalizes the offset bitwidth to the stripped pointer type, not the /// original pointer type. -static APInt stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V, - bool AllowNonInbounds = false) { +static APInt stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V) { assert(V->getType()->isPtrOrPtrVectorTy()); APInt Offset = APInt::getZero(DL.getIndexTypeSizeInBits(V->getType())); - V = V->stripAndAccumulateConstantOffsets(DL, Offset, AllowNonInbounds); + V = V->stripAndAccumulateConstantOffsets(DL, Offset, + /*AllowNonInbounds=*/true); // As that strip may trace through `addrspacecast`, need to sext or trunc // the offset calculated. return Offset.sextOrTrunc(DL.getIndexTypeSizeInBits(V->getType())); @@ -853,10 +853,12 @@ static Value *simplifySubInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, return W; // Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...). - if (match(Op0, m_PtrToInt(m_Value(X))) && match(Op1, m_PtrToInt(m_Value(Y)))) + if (match(Op0, m_PtrToIntOrAddr(m_Value(X))) && + match(Op1, m_PtrToIntOrAddr(m_Value(Y)))) { if (Constant *Result = computePointerDifference(Q.DL, X, Y)) return ConstantFoldIntegerCast(Result, Op0->getType(), /*IsSigned*/ true, Q.DL); + } // i1 sub -> xor. if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1)) diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp index 6e92766..813632c 100644 --- a/llvm/lib/Analysis/TargetLibraryInfo.cpp +++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -740,11 +740,6 @@ static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T, TLI.setAvailable(LibFunc_fgets_unlocked); } - if (T.isAndroid() && T.isAndroidVersionLT(21)) { - TLI.setUnavailable(LibFunc_stpcpy); - TLI.setUnavailable(LibFunc_stpncpy); - } - if (T.isPS()) { // PS4/PS5 do have memalign. TLI.setAvailable(LibFunc_memalign); diff --git a/llvm/lib/AsmParser/LLLexer.cpp b/llvm/lib/AsmParser/LLLexer.cpp index f6937d3..50d1d47 100644 --- a/llvm/lib/AsmParser/LLLexer.cpp +++ b/llvm/lib/AsmParser/LLLexer.cpp @@ -982,6 +982,7 @@ lltok::Kind LLLexer::LexIdentifier() { DWKEYWORD(ATE, DwarfAttEncoding); DWKEYWORD(VIRTUALITY, DwarfVirtuality); DWKEYWORD(LANG, DwarfLang); + DWKEYWORD(LNAME, DwarfSourceLangName); DWKEYWORD(CC, DwarfCC); DWKEYWORD(OP, DwarfOp); DWKEYWORD(MACINFO, DwarfMacinfo); diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index 5589966..380b192 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -4740,6 +4740,10 @@ struct DwarfLangField : public MDUnsignedField { DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {} }; +struct DwarfSourceLangNameField : public MDUnsignedField { + DwarfSourceLangNameField() : MDUnsignedField(0, UINT32_MAX) {} +}; + struct DwarfCCField : public MDUnsignedField { DwarfCCField() : MDUnsignedField(0, dwarf::DW_CC_hi_user) {} }; @@ -4998,6 +5002,25 @@ bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) { } template <> +bool LLParser::parseMDField(LocTy Loc, StringRef Name, + DwarfSourceLangNameField &Result) { + if (Lex.getKind() == lltok::APSInt) + return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); + + if (Lex.getKind() != lltok::DwarfSourceLangName) + return tokError("expected DWARF source language name"); + + unsigned Lang = dwarf::getSourceLanguageName(Lex.getStrVal()); + if (!Lang) + return tokError("invalid DWARF source language name" + Twine(" '") + + Lex.getStrVal() + "'"); + assert(Lang <= Result.Max && "Expected valid DWARF source language name"); + Result.assign(Lang); + Lex.Lex(); + return false; +} + +template <> bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) { if (Lex.getKind() == lltok::APSInt) return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result)); @@ -5836,9 +5859,12 @@ bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) { if (!IsDistinct) return tokError("missing 'distinct', required for !DICompileUnit"); + LocTy Loc = Lex.getLoc(); + #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \ - REQUIRED(language, DwarfLangField, ); \ REQUIRED(file, MDField, (/* AllowNull */ false)); \ + OPTIONAL(language, DwarfLangField, ); \ + OPTIONAL(sourceLanguageName, DwarfSourceLangNameField, ); \ OPTIONAL(producer, MDStringField, ); \ OPTIONAL(isOptimized, MDBoolField, ); \ OPTIONAL(flags, MDStringField, ); \ @@ -5860,12 +5886,23 @@ bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) { PARSE_MD_FIELDS(); #undef VISIT_MD_FIELDS + if (!language.Seen && !sourceLanguageName.Seen) + return error(Loc, "missing one of 'language' or 'sourceLanguageName', " + "required for !DICompileUnit"); + + if (language.Seen && sourceLanguageName.Seen) + return error(Loc, "can only specify one of 'language' and " + "'sourceLanguageName' on !DICompileUnit"); + Result = DICompileUnit::getDistinct( - Context, DISourceLanguageName(language.Val), file.Val, producer.Val, - isOptimized.Val, flags.Val, runtimeVersion.Val, splitDebugFilename.Val, - emissionKind.Val, enums.Val, retainedTypes.Val, globals.Val, imports.Val, - macros.Val, dwoId.Val, splitDebugInlining.Val, debugInfoForProfiling.Val, - nameTableKind.Val, rangesBaseAddress.Val, sysroot.Val, sdk.Val); + Context, + language.Seen ? DISourceLanguageName(language.Val) + : DISourceLanguageName(sourceLanguageName.Val, 0), + file.Val, producer.Val, isOptimized.Val, flags.Val, runtimeVersion.Val, + splitDebugFilename.Val, emissionKind.Val, enums.Val, retainedTypes.Val, + globals.Val, imports.Val, macros.Val, dwoId.Val, splitDebugInlining.Val, + debugInfoForProfiling.Val, nameTableKind.Val, rangesBaseAddress.Val, + sysroot.Val, sdk.Val); return false; } diff --git a/llvm/lib/BinaryFormat/Dwarf.cpp b/llvm/lib/BinaryFormat/Dwarf.cpp index 969047a..55fa2df 100644 --- a/llvm/lib/BinaryFormat/Dwarf.cpp +++ b/llvm/lib/BinaryFormat/Dwarf.cpp @@ -893,6 +893,8 @@ StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) { return DefaultedMemberString(Val); case DW_AT_APPLE_enum_kind: return EnumKindString(Val); + case DW_AT_language_name: + return SourceLanguageNameString(static_cast<SourceLanguageName>(Val)); } return StringRef(); diff --git a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp index a4d1b83..cdcf7a8 100644 --- a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp +++ b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp @@ -1867,12 +1867,18 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata( // distinct. It's always distinct. IsDistinct = true; + const auto LangVersionMask = (uint64_t(1) << 63); + const bool HasVersionedLanguage = Record[1] & LangVersionMask; + auto *CU = DICompileUnit::getDistinct( - Context, DISourceLanguageName(Record[1]), getMDOrNull(Record[2]), - getMDString(Record[3]), Record[4], getMDString(Record[5]), Record[6], - getMDString(Record[7]), Record[8], getMDOrNull(Record[9]), - getMDOrNull(Record[10]), getMDOrNull(Record[12]), - getMDOrNull(Record[13]), + Context, + HasVersionedLanguage + ? DISourceLanguageName(Record[1] & ~LangVersionMask, 0) + : DISourceLanguageName(Record[1]), + getMDOrNull(Record[2]), getMDString(Record[3]), Record[4], + getMDString(Record[5]), Record[6], getMDString(Record[7]), Record[8], + getMDOrNull(Record[9]), getMDOrNull(Record[10]), + getMDOrNull(Record[12]), getMDOrNull(Record[13]), Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]), Record.size() <= 14 ? 0 : Record[14], Record.size() <= 16 ? true : Record[16], diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 7ed140d..0ca55a26 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -2108,7 +2108,13 @@ void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N, assert(N->isDistinct() && "Expected distinct compile units"); Record.push_back(/* IsDistinct */ true); - Record.push_back(N->getSourceLanguage().getUnversionedName()); + auto Lang = N->getSourceLanguage(); + Record.push_back(Lang.getName()); + // Set bit so the MetadataLoader can distniguish between versioned and + // unversioned names. + if (Lang.hasVersionedName()) + Record.back() ^= (uint64_t(1) << 63); + Record.push_back(VE.getMetadataOrNullID(N->getFile())); Record.push_back(VE.getMetadataOrNullID(N->getRawProducer())); Record.push_back(N->isOptimized()); diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp index bc0bb34..f0f0861 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp @@ -587,10 +587,12 @@ bool DwarfExpression::addExpression( emitUnsigned(LeftShift); emitOp(dwarf::DW_OP_shl); } - emitOp(dwarf::DW_OP_constu); - emitUnsigned(RightShift); - emitOp(OpNum == dwarf::DW_OP_LLVM_extract_bits_sext ? dwarf::DW_OP_shra - : dwarf::DW_OP_shr); + if (RightShift) { + emitOp(dwarf::DW_OP_constu); + emitUnsigned(RightShift); + emitOp(OpNum == dwarf::DW_OP_LLVM_extract_bits_sext ? dwarf::DW_OP_shra + : dwarf::DW_OP_shr); + } // The value is now at the top of the stack, so set the location to // implicit so that we get a stack_value at the end. diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp index eb73d01b..4320b1d 100644 --- a/llvm/lib/CodeGen/CodeGenPrepare.cpp +++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp @@ -3194,7 +3194,7 @@ struct ExtAddrMode : public TargetLowering::AddrMode { case ScaledRegField: return ScaledReg; case BaseOffsField: - return ConstantInt::get(IntPtrTy, BaseOffs); + return ConstantInt::getSigned(IntPtrTy, BaseOffs); } } @@ -6100,7 +6100,7 @@ bool CodeGenPrepare::optimizeMemoryInst(Instruction *MemoryInst, Value *Addr, // Add in the Base Offset if present. if (AddrMode.BaseOffs) { - Value *V = ConstantInt::get(IntPtrTy, AddrMode.BaseOffs); + Value *V = ConstantInt::getSigned(IntPtrTy, AddrMode.BaseOffs); if (ResultIndex) { // We need to add this separately from the scale above to help with // SDAG consecutive load/store merging. @@ -6226,7 +6226,7 @@ bool CodeGenPrepare::optimizeMemoryInst(Instruction *MemoryInst, Value *Addr, // Add in the Base Offset if present. if (AddrMode.BaseOffs) { - Value *V = ConstantInt::get(IntPtrTy, AddrMode.BaseOffs); + Value *V = ConstantInt::getSigned(IntPtrTy, AddrMode.BaseOffs); if (Result) Result = Builder.CreateAdd(Result, V, "sunkaddr"); else diff --git a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp index 906d62a3..b425b95 100644 --- a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp +++ b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp @@ -1728,6 +1728,7 @@ static APFloat constantFoldFpUnary(const MachineInstr &MI, Result.clearSign(); return Result; } + case TargetOpcode::G_FPEXT: case TargetOpcode::G_FPTRUNC: { bool Unused; LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); diff --git a/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp b/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp index 3f6813e..90c60d4 100644 --- a/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp +++ b/llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp @@ -344,6 +344,22 @@ void GISelValueTracking::computeKnownBitsImpl(Register R, KnownBits &Known, Known = KnownBits::mul(Known, Known2); break; } + case TargetOpcode::G_UMULH: { + computeKnownBitsImpl(MI.getOperand(2).getReg(), Known, DemandedElts, + Depth + 1); + computeKnownBitsImpl(MI.getOperand(1).getReg(), Known2, DemandedElts, + Depth + 1); + Known = KnownBits::mulhu(Known, Known2); + break; + } + case TargetOpcode::G_SMULH: { + computeKnownBitsImpl(MI.getOperand(2).getReg(), Known, DemandedElts, + Depth + 1); + computeKnownBitsImpl(MI.getOperand(1).getReg(), Known2, DemandedElts, + Depth + 1); + Known = KnownBits::mulhs(Known, Known2); + break; + } case TargetOpcode::G_SELECT: { computeKnownBitsMin(MI.getOperand(2).getReg(), MI.getOperand(3).getReg(), Known, DemandedElts, Depth + 1); diff --git a/llvm/lib/CodeGen/RegisterCoalescer.cpp b/llvm/lib/CodeGen/RegisterCoalescer.cpp index ebfea8e..e17a214 100644 --- a/llvm/lib/CodeGen/RegisterCoalescer.cpp +++ b/llvm/lib/CodeGen/RegisterCoalescer.cpp @@ -2051,6 +2051,12 @@ bool RegisterCoalescer::joinCopy( } if (CP.getNewRC()) { + if (RegClassInfo.getNumAllocatableRegs(CP.getNewRC()) == 0) { + LLVM_DEBUG(dbgs() << "\tNo " << TRI->getRegClassName(CP.getNewRC()) + << "are available for allocation\n"); + return false; + } + auto SrcRC = MRI->getRegClass(CP.getSrcReg()); auto DstRC = MRI->getRegClass(CP.getDstReg()); unsigned SrcIdx = CP.getSrcIdx(); diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp index edc69a3..212a0c0 100644 --- a/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp +++ b/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp @@ -149,7 +149,8 @@ static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die, if (!Name.empty()) WithColor(OS, Color) << Name; else if (Attr == DW_AT_decl_line || Attr == DW_AT_decl_column || - Attr == DW_AT_call_line || Attr == DW_AT_call_column) { + Attr == DW_AT_call_line || Attr == DW_AT_call_column || + Attr == DW_AT_language_version) { if (std::optional<uint64_t> Val = FormValue.getAsUnsignedConstant()) OS << *Val; else diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp index ae086bcd..0bc877d 100644 --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -2370,10 +2370,16 @@ static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N, Out << "!DICompileUnit("; MDFieldPrinter Printer(Out, WriterCtx); - Printer.printDwarfEnum("language", - N->getSourceLanguage().getUnversionedName(), - dwarf::LanguageString, - /* ShouldSkipZero */ false); + auto Lang = N->getSourceLanguage(); + if (Lang.hasVersionedName()) + Printer.printDwarfEnum( + "sourceLanguageName", + static_cast<llvm::dwarf::SourceLanguageName>(Lang.getName()), + dwarf::SourceLanguageNameString, + /* ShouldSkipZero */ false); + else + Printer.printDwarfEnum("language", Lang.getName(), dwarf::LanguageString, + /* ShouldSkipZero */ false); Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false); Printer.printString("producer", N->getProducer()); diff --git a/llvm/lib/IR/ConstantFPRange.cpp b/llvm/lib/IR/ConstantFPRange.cpp index 7509188..fba6942 100644 --- a/llvm/lib/IR/ConstantFPRange.cpp +++ b/llvm/lib/IR/ConstantFPRange.cpp @@ -391,3 +391,23 @@ ConstantFPRange ConstantFPRange::unionWith(const ConstantFPRange &CR) const { return ConstantFPRange(minnum(Lower, CR.Lower), maxnum(Upper, CR.Upper), MayBeQNaN | CR.MayBeQNaN, MayBeSNaN | CR.MayBeSNaN); } + +ConstantFPRange ConstantFPRange::abs() const { + if (isNaNOnly()) + return *this; + // Check if the range is all non-negative or all non-positive. + if (Lower.isNegative() == Upper.isNegative()) { + if (Lower.isNegative()) + return negate(); + return *this; + } + // The range contains both positive and negative values. + APFloat NewLower = APFloat::getZero(getSemantics()); + APFloat NewUpper = maxnum(-Lower, Upper); + return ConstantFPRange(std::move(NewLower), std::move(NewUpper), MayBeQNaN, + MayBeSNaN); +} + +ConstantFPRange ConstantFPRange::negate() const { + return ConstantFPRange(-Upper, -Lower, MayBeQNaN, MayBeSNaN); +} diff --git a/llvm/lib/Target/AArch64/AArch64Combine.td b/llvm/lib/Target/AArch64/AArch64Combine.td index 639ddcb..ecaeff7 100644 --- a/llvm/lib/Target/AArch64/AArch64Combine.td +++ b/llvm/lib/Target/AArch64/AArch64Combine.td @@ -350,7 +350,7 @@ def AArch64PostLegalizerLowering // Post-legalization combines which are primarily optimizations. def AArch64PostLegalizerCombiner : GICombiner<"AArch64PostLegalizerCombinerImpl", - [copy_prop, cast_of_cast_combines, + [copy_prop, cast_of_cast_combines, constant_fold_fp_ops, buildvector_of_truncate, integer_of_truncate, mutate_anyext_to_zext, combines_for_extload, combine_indexed_load_store, sext_trunc_sextload, diff --git a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp index 31b3d18..7294f3e 100644 --- a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp +++ b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp @@ -16249,7 +16249,9 @@ SDValue AArch64TargetLowering::LowerDIV(SDValue Op, SelectionDAG &DAG) const { bool Negated; uint64_t SplatVal; - if (Signed && isPow2Splat(Op.getOperand(1), SplatVal, Negated)) { + // NOTE: SRAD cannot be used to represent sdiv-by-one. + if (Signed && isPow2Splat(Op.getOperand(1), SplatVal, Negated) && + SplatVal > 1) { SDValue Pg = getPredicateForScalableVector(DAG, DL, VT); SDValue Res = DAG.getNode(AArch64ISD::SRAD_MERGE_OP1, DL, VT, Pg, Op->getOperand(0), @@ -30034,7 +30036,9 @@ SDValue AArch64TargetLowering::LowerFixedLengthVectorIntDivideToSVE( bool Negated; uint64_t SplatVal; - if (Signed && isPow2Splat(Op.getOperand(1), SplatVal, Negated)) { + // NOTE: SRAD cannot be used to represent sdiv-by-one. + if (Signed && isPow2Splat(Op.getOperand(1), SplatVal, Negated) && + SplatVal > 1) { EVT ContainerVT = getContainerForFixedLengthVector(DAG, VT); SDValue Op1 = convertToScalableVector(DAG, ContainerVT, Op.getOperand(0)); SDValue Op2 = DAG.getTargetConstant(Log2_64(SplatVal), DL, MVT::i32); @@ -30606,6 +30610,43 @@ AArch64TargetLowering::LowerVECTOR_DEINTERLEAVE(SDValue Op, assert(OpVT.isScalableVector() && "Expected scalable vector in LowerVECTOR_DEINTERLEAVE."); + if (Op->getNumOperands() == 3) { + // aarch64_sve_ld3 only supports packed datatypes. + EVT PackedVT = getPackedSVEVectorVT(OpVT.getVectorElementCount()); + Align Alignment = DAG.getReducedAlign(PackedVT, /*UseABI=*/false); + SDValue StackPtr = + DAG.CreateStackTemporary(PackedVT.getStoreSize() * 3, Alignment); + + // Write out unmodified operands. + SmallVector<SDValue, 3> Chains; + for (unsigned I = 0; I < 3; ++I) { + SDValue Ptr = + DAG.getMemBasePlusOffset(StackPtr, PackedVT.getStoreSize() * I, DL); + SDValue V = getSVESafeBitCast(PackedVT, Op.getOperand(I), DAG); + Chains.push_back( + DAG.getStore(DAG.getEntryNode(), DL, V, Ptr, MachinePointerInfo())); + } + + Intrinsic::ID IntID = Intrinsic::aarch64_sve_ld3_sret; + EVT PredVT = PackedVT.changeVectorElementType(MVT::i1); + + SmallVector<SDValue, 7> Ops; + Ops.push_back(DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains)); + Ops.push_back(DAG.getTargetConstant(IntID, DL, MVT::i64)); + Ops.push_back(DAG.getConstant(1, DL, PredVT)); + Ops.push_back(StackPtr); + + // Read back and deinterleave data. + SDVTList VTs = DAG.getVTList(PackedVT, PackedVT, PackedVT, MVT::Other); + SDValue LD3 = DAG.getNode(ISD::INTRINSIC_W_CHAIN, DL, VTs, Ops); + + SmallVector<SDValue, 3> Results; + Results.push_back(getSVESafeBitCast(OpVT, LD3.getValue(0), DAG)); + Results.push_back(getSVESafeBitCast(OpVT, LD3.getValue(1), DAG)); + Results.push_back(getSVESafeBitCast(OpVT, LD3.getValue(2), DAG)); + return DAG.getMergeValues(Results, DL); + } + // Are multi-register uzp instructions available? if (Subtarget->hasSME2() && Subtarget->isStreaming() && OpVT.getVectorElementType() != MVT::i1) { @@ -30647,6 +30688,42 @@ SDValue AArch64TargetLowering::LowerVECTOR_INTERLEAVE(SDValue Op, assert(OpVT.isScalableVector() && "Expected scalable vector in LowerVECTOR_INTERLEAVE."); + if (Op->getNumOperands() == 3) { + // aarch64_sve_st3 only supports packed datatypes. + EVT PackedVT = getPackedSVEVectorVT(OpVT.getVectorElementCount()); + SmallVector<SDValue, 3> InVecs; + for (SDValue V : Op->ops()) + InVecs.push_back(getSVESafeBitCast(PackedVT, V, DAG)); + + Align Alignment = DAG.getReducedAlign(PackedVT, /*UseABI=*/false); + SDValue StackPtr = + DAG.CreateStackTemporary(PackedVT.getStoreSize() * 3, Alignment); + + Intrinsic::ID IntID = Intrinsic::aarch64_sve_st3; + EVT PredVT = PackedVT.changeVectorElementType(MVT::i1); + + SmallVector<SDValue, 7> Ops; + Ops.push_back(DAG.getEntryNode()); + Ops.push_back(DAG.getTargetConstant(IntID, DL, MVT::i64)); + Ops.append(InVecs); + Ops.push_back(DAG.getConstant(1, DL, PredVT)); + Ops.push_back(StackPtr); + + // Interleave operands and store. + SDValue Chain = DAG.getNode(ISD::INTRINSIC_VOID, DL, MVT::Other, Ops); + + // Read back the interleaved data. + SmallVector<SDValue, 3> Results; + for (unsigned I = 0; I < 3; ++I) { + SDValue Ptr = + DAG.getMemBasePlusOffset(StackPtr, PackedVT.getStoreSize() * I, DL); + SDValue L = DAG.getLoad(PackedVT, DL, Chain, Ptr, MachinePointerInfo()); + Results.push_back(getSVESafeBitCast(OpVT, L, DAG)); + } + + return DAG.getMergeValues(Results, DL); + } + // Are multi-register zip instructions available? if (Subtarget->hasSME2() && Subtarget->isStreaming() && OpVT.getVectorElementType() != MVT::i1) { diff --git a/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp b/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp index 24bef82..8e35ba7 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp @@ -15,6 +15,7 @@ #include "AMDGPU.h" #include "AMDGPUTargetMachine.h" #include "SIModeRegisterDefaults.h" +#include "llvm/ADT/SetVector.h" #include "llvm/Analysis/AssumptionCache.h" #include "llvm/Analysis/ConstantFolding.h" #include "llvm/Analysis/TargetLibraryInfo.h" @@ -27,6 +28,7 @@ #include "llvm/IR/InstVisitor.h" #include "llvm/IR/IntrinsicsAMDGPU.h" #include "llvm/IR/PatternMatch.h" +#include "llvm/IR/ValueHandle.h" #include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/Support/KnownBits.h" @@ -106,6 +108,7 @@ public: bool FlowChanged = false; mutable Function *SqrtF32 = nullptr; mutable Function *LdexpF32 = nullptr; + mutable SmallVector<WeakVH> DeadVals; DenseMap<const PHINode *, bool> BreakPhiNodesCache; @@ -242,6 +245,8 @@ public: Value *emitSqrtIEEE2ULP(IRBuilder<> &Builder, Value *Src, FastMathFlags FMF) const; + bool tryNarrowMathIfNoOverflow(Instruction *I); + public: bool visitFDiv(BinaryOperator &I); @@ -281,28 +286,21 @@ bool AMDGPUCodeGenPrepareImpl::run() { BreakPhiNodesCache.clear(); bool MadeChange = false; - Function::iterator NextBB; - for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; FI = NextBB) { - BasicBlock *BB = &*FI; - NextBB = std::next(FI); - - BasicBlock::iterator Next; - for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; - I = Next) { - Next = std::next(I); - - MadeChange |= visit(*I); - - if (Next != E) { // Control flow changed - BasicBlock *NextInstBB = Next->getParent(); - if (NextInstBB != BB) { - BB = NextInstBB; - E = BB->end(); - FE = F.end(); - } - } + // Need to use make_early_inc_range because integer division expansion is + // handled by Transform/Utils, and it can delete instructions such as the + // terminator of the BB. + for (BasicBlock &BB : reverse(F)) { + for (Instruction &I : make_early_inc_range(reverse(BB))) { + if (!isInstructionTriviallyDead(&I, TLI)) + MadeChange |= visit(I); } } + + while (!DeadVals.empty()) { + if (auto *I = dyn_cast_or_null<Instruction>(DeadVals.pop_back_val())) + RecursivelyDeleteTriviallyDeadInstructions(I, TLI); + } + return MadeChange; } @@ -422,7 +420,7 @@ bool AMDGPUCodeGenPrepareImpl::replaceMulWithMul24(BinaryOperator &I) const { Value *NewVal = insertValues(Builder, Ty, ResultVals); NewVal->takeName(&I); I.replaceAllUsesWith(NewVal); - I.eraseFromParent(); + DeadVals.push_back(&I); return true; } @@ -496,10 +494,10 @@ bool AMDGPUCodeGenPrepareImpl::foldBinOpIntoSelect(BinaryOperator &BO) const { FoldedT, FoldedF); NewSelect->takeName(&BO); BO.replaceAllUsesWith(NewSelect); - BO.eraseFromParent(); + DeadVals.push_back(&BO); if (CastOp) - CastOp->eraseFromParent(); - Sel->eraseFromParent(); + DeadVals.push_back(CastOp); + DeadVals.push_back(Sel); return true; } @@ -895,7 +893,7 @@ bool AMDGPUCodeGenPrepareImpl::visitFDiv(BinaryOperator &FDiv) { if (NewVal) { FDiv.replaceAllUsesWith(NewVal); NewVal->takeName(&FDiv); - RecursivelyDeleteTriviallyDeadInstructions(&FDiv, TLI); + DeadVals.push_back(&FDiv); } return true; @@ -1302,10 +1300,7 @@ it will create `s_and_b32 s0, s0, 0xff`. We accept this change since the non-byte load assumes the upper bits within the byte are all 0. */ -static bool tryNarrowMathIfNoOverflow(Instruction *I, - const SITargetLowering *TLI, - const TargetTransformInfo &TTI, - const DataLayout &DL) { +bool AMDGPUCodeGenPrepareImpl::tryNarrowMathIfNoOverflow(Instruction *I) { unsigned Opc = I->getOpcode(); Type *OldType = I->getType(); @@ -1330,6 +1325,7 @@ static bool tryNarrowMathIfNoOverflow(Instruction *I, NewType = I->getType()->getWithNewBitWidth(NewBit); // Old cost + const TargetTransformInfo &TTI = TM.getTargetTransformInfo(F); InstructionCost OldCost = TTI.getArithmeticInstrCost(Opc, OldType, TTI::TCK_RecipThroughput); // New cost of new op @@ -1360,7 +1356,7 @@ static bool tryNarrowMathIfNoOverflow(Instruction *I, Value *Zext = Builder.CreateZExt(Arith, OldType); I->replaceAllUsesWith(Zext); - I->eraseFromParent(); + DeadVals.push_back(I); return true; } @@ -1370,8 +1366,7 @@ bool AMDGPUCodeGenPrepareImpl::visitBinaryOperator(BinaryOperator &I) { if (UseMul24Intrin && replaceMulWithMul24(I)) return true; - if (tryNarrowMathIfNoOverflow(&I, ST.getTargetLowering(), - TM.getTargetTransformInfo(F), DL)) + if (tryNarrowMathIfNoOverflow(&I)) return true; bool Changed = false; @@ -1436,7 +1431,7 @@ bool AMDGPUCodeGenPrepareImpl::visitBinaryOperator(BinaryOperator &I) { if (NewDiv) { I.replaceAllUsesWith(NewDiv); - I.eraseFromParent(); + DeadVals.push_back(&I); Changed = true; } } @@ -1492,7 +1487,7 @@ bool AMDGPUCodeGenPrepareImpl::visitLoadInst(LoadInst &I) { Value *ValTrunc = Builder.CreateTrunc(WidenLoad, IntNTy); Value *ValOrig = Builder.CreateBitCast(ValTrunc, I.getType()); I.replaceAllUsesWith(ValOrig); - I.eraseFromParent(); + DeadVals.push_back(&I); return true; } @@ -1534,7 +1529,7 @@ bool AMDGPUCodeGenPrepareImpl::visitSelectInst(SelectInst &I) { Fract->takeName(&I); I.replaceAllUsesWith(Fract); - RecursivelyDeleteTriviallyDeadInstructions(&I, TLI); + DeadVals.push_back(&I); return true; } @@ -1822,7 +1817,7 @@ bool AMDGPUCodeGenPrepareImpl::visitPHINode(PHINode &I) { } I.replaceAllUsesWith(Vec); - I.eraseFromParent(); + DeadVals.push_back(&I); return true; } @@ -1903,7 +1898,7 @@ bool AMDGPUCodeGenPrepareImpl::visitAddrSpaceCastInst(AddrSpaceCastInst &I) { auto *Intrin = B.CreateIntrinsic( I.getType(), Intrinsic::amdgcn_addrspacecast_nonnull, {I.getOperand(0)}); I.replaceAllUsesWith(Intrin); - I.eraseFromParent(); + DeadVals.push_back(&I); return true; } @@ -2000,16 +1995,10 @@ bool AMDGPUCodeGenPrepareImpl::visitFMinLike(IntrinsicInst &I) { Value *Fract = applyFractPat(Builder, FractArg); Fract->takeName(&I); I.replaceAllUsesWith(Fract); - - RecursivelyDeleteTriviallyDeadInstructions(&I, TLI); + DeadVals.push_back(&I); return true; } -static bool isOneOrNegOne(const Value *Val) { - const APFloat *C; - return match(Val, m_APFloat(C)) && C->getExactLog2Abs() == 0; -} - // Expand llvm.sqrt.f32 calls with !fpmath metadata in a semi-fast way. bool AMDGPUCodeGenPrepareImpl::visitSqrt(IntrinsicInst &Sqrt) { Type *Ty = Sqrt.getType()->getScalarType(); @@ -2030,18 +2019,6 @@ bool AMDGPUCodeGenPrepareImpl::visitSqrt(IntrinsicInst &Sqrt) { if (ReqdAccuracy < 1.0f) return false; - // FIXME: This is an ugly hack for this pass using forward iteration instead - // of reverse. If it worked like a normal combiner, the rsq would form before - // we saw a sqrt call. - auto *FDiv = - dyn_cast_or_null<FPMathOperator>(Sqrt.getUniqueUndroppableUser()); - if (FDiv && FDiv->getOpcode() == Instruction::FDiv && - FDiv->getFPAccuracy() >= 1.0f && - canOptimizeWithRsq(FPOp, FDiv->getFastMathFlags(), SqrtFMF) && - // TODO: We should also handle the arcp case for the fdiv with non-1 value - isOneOrNegOne(FDiv->getOperand(0))) - return false; - Value *SrcVal = Sqrt.getOperand(0); bool CanTreatAsDAZ = canIgnoreDenormalInput(SrcVal, &Sqrt); @@ -2065,7 +2042,7 @@ bool AMDGPUCodeGenPrepareImpl::visitSqrt(IntrinsicInst &Sqrt) { Value *NewSqrt = insertValues(Builder, Sqrt.getType(), ResultVals); NewSqrt->takeName(&Sqrt); Sqrt.replaceAllUsesWith(NewSqrt); - Sqrt.eraseFromParent(); + DeadVals.push_back(&Sqrt); return true; } diff --git a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.cpp b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.cpp index 73b2660..5407566 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.cpp @@ -468,6 +468,38 @@ void RegBankLegalizeHelper::lowerUnpackBitShift(MachineInstr &MI) { MI.eraseFromParent(); } +void RegBankLegalizeHelper::lowerUnpackMinMax(MachineInstr &MI) { + Register Lo, Hi; + switch (MI.getOpcode()) { + case AMDGPU::G_SMIN: + case AMDGPU::G_SMAX: { + // For signed operations, use sign extension + auto [Val0_Lo, Val0_Hi] = unpackSExt(MI.getOperand(1).getReg()); + auto [Val1_Lo, Val1_Hi] = unpackSExt(MI.getOperand(2).getReg()); + Lo = B.buildInstr(MI.getOpcode(), {SgprRB_S32}, {Val0_Lo, Val1_Lo}) + .getReg(0); + Hi = B.buildInstr(MI.getOpcode(), {SgprRB_S32}, {Val0_Hi, Val1_Hi}) + .getReg(0); + break; + } + case AMDGPU::G_UMIN: + case AMDGPU::G_UMAX: { + // For unsigned operations, use zero extension + auto [Val0_Lo, Val0_Hi] = unpackZExt(MI.getOperand(1).getReg()); + auto [Val1_Lo, Val1_Hi] = unpackZExt(MI.getOperand(2).getReg()); + Lo = B.buildInstr(MI.getOpcode(), {SgprRB_S32}, {Val0_Lo, Val1_Lo}) + .getReg(0); + Hi = B.buildInstr(MI.getOpcode(), {SgprRB_S32}, {Val0_Hi, Val1_Hi}) + .getReg(0); + break; + } + default: + llvm_unreachable("Unpack min/max lowering not implemented"); + } + B.buildBuildVectorTrunc(MI.getOperand(0).getReg(), {Lo, Hi}); + MI.eraseFromParent(); +} + static bool isSignedBFE(MachineInstr &MI) { if (GIntrinsic *GI = dyn_cast<GIntrinsic>(&MI)) return (GI->is(Intrinsic::amdgcn_sbfe)); @@ -654,6 +686,8 @@ void RegBankLegalizeHelper::lower(MachineInstr &MI, } case UnpackBitShift: return lowerUnpackBitShift(MI); + case UnpackMinMax: + return lowerUnpackMinMax(MI); case Ext32To64: { const RegisterBank *RB = MRI.getRegBank(MI.getOperand(0).getReg()); MachineInstrBuilder Hi; diff --git a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.h b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.h index 7affe5a..d937815 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.h +++ b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeHelper.h @@ -123,6 +123,7 @@ private: void lowerSplitTo32(MachineInstr &MI); void lowerSplitTo32Select(MachineInstr &MI); void lowerSplitTo32SExtInReg(MachineInstr &MI); + void lowerUnpackMinMax(MachineInstr &MI); }; } // end namespace AMDGPU diff --git a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.cpp b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.cpp index f413bbc..7392f4b 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.cpp @@ -522,6 +522,22 @@ RegBankLegalizeRules::RegBankLegalizeRules(const GCNSubtarget &_ST, .Uni(S64, {{Sgpr64}, {Sgpr64, Sgpr32, Sgpr32}, S_BFE}) .Div(S64, {{Vgpr64}, {Vgpr64, Vgpr32, Vgpr32}, V_BFE}); + addRulesForGOpcs({G_SMIN, G_SMAX}, Standard) + .Uni(S16, {{Sgpr32Trunc}, {Sgpr32SExt, Sgpr32SExt}}) + .Div(S16, {{Vgpr16}, {Vgpr16, Vgpr16}}) + .Uni(S32, {{Sgpr32}, {Sgpr32, Sgpr32}}) + .Div(S32, {{Vgpr32}, {Vgpr32, Vgpr32}}) + .Uni(V2S16, {{SgprV2S16}, {SgprV2S16, SgprV2S16}, UnpackMinMax}) + .Div(V2S16, {{VgprV2S16}, {VgprV2S16, VgprV2S16}}); + + addRulesForGOpcs({G_UMIN, G_UMAX}, Standard) + .Uni(S16, {{Sgpr32Trunc}, {Sgpr32ZExt, Sgpr32ZExt}}) + .Div(S16, {{Vgpr16}, {Vgpr16, Vgpr16}}) + .Uni(S32, {{Sgpr32}, {Sgpr32, Sgpr32}}) + .Div(S32, {{Vgpr32}, {Vgpr32, Vgpr32}}) + .Uni(V2S16, {{SgprV2S16}, {SgprV2S16, SgprV2S16}, UnpackMinMax}) + .Div(V2S16, {{VgprV2S16}, {VgprV2S16, VgprV2S16}}); + // Note: we only write S1 rules for G_IMPLICIT_DEF, G_CONSTANT, G_FCONSTANT // and G_FREEZE here, rest is trivially regbankselected earlier addRulesForGOpcs({G_IMPLICIT_DEF}).Any({{UniS1}, {{Sgpr32Trunc}, {}}}); diff --git a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.h b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.h index d0c6910..93e0efd 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.h +++ b/llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.h @@ -212,6 +212,7 @@ enum LoweringMethodID { VccExtToSel, UniExtToSel, UnpackBitShift, + UnpackMinMax, S_BFE, V_BFE, VgprToVccCopy, diff --git a/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp index 557d87f..56807a4 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp @@ -5053,16 +5053,18 @@ AMDGPURegisterBankInfo::getInstrMapping(const MachineInstr &MI) const { // // vdst, srcA, srcB, srcC const SIMachineFunctionInfo *Info = MF.getInfo<SIMachineFunctionInfo>(); + + bool UseAGPRForm = !Subtarget.hasGFX90AInsts() || + Info->selectAGPRFormMFMA(MinNumRegsRequired); + OpdsMapping[0] = - Info->getMinNumAGPRs() >= MinNumRegsRequired - ? getAGPROpMapping(MI.getOperand(0).getReg(), MRI, *TRI) - : getVGPROpMapping(MI.getOperand(0).getReg(), MRI, *TRI); + UseAGPRForm ? getAGPROpMapping(MI.getOperand(0).getReg(), MRI, *TRI) + : getVGPROpMapping(MI.getOperand(0).getReg(), MRI, *TRI); OpdsMapping[2] = getVGPROpMapping(MI.getOperand(2).getReg(), MRI, *TRI); OpdsMapping[3] = getVGPROpMapping(MI.getOperand(3).getReg(), MRI, *TRI); OpdsMapping[4] = - Info->getMinNumAGPRs() >= MinNumRegsRequired - ? getAGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI) - : getVGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI); + UseAGPRForm ? getAGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI) + : getVGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI); break; } case Intrinsic::amdgcn_mfma_scale_f32_16x16x128_f8f6f4: @@ -5115,11 +5117,21 @@ AMDGPURegisterBankInfo::getInstrMapping(const MachineInstr &MI) const { case Intrinsic::amdgcn_smfmac_f32_32x32x64_bf8_fp8: case Intrinsic::amdgcn_smfmac_f32_32x32x64_fp8_bf8: case Intrinsic::amdgcn_smfmac_f32_32x32x64_fp8_fp8: { + Register DstReg = MI.getOperand(0).getReg(); + unsigned DstSize = MRI.getType(DstReg).getSizeInBits(); + unsigned MinNumRegsRequired = DstSize / 32; + const SIMachineFunctionInfo *Info = MF.getInfo<SIMachineFunctionInfo>(); + bool UseAGPRForm = Info->selectAGPRFormMFMA(MinNumRegsRequired); + // vdst, srcA, srcB, srcC, idx - OpdsMapping[0] = getAGPROpMapping(MI.getOperand(0).getReg(), MRI, *TRI); + OpdsMapping[0] = UseAGPRForm ? getAGPROpMapping(DstReg, MRI, *TRI) + : getVGPROpMapping(DstReg, MRI, *TRI); + OpdsMapping[2] = getVGPROpMapping(MI.getOperand(2).getReg(), MRI, *TRI); OpdsMapping[3] = getVGPROpMapping(MI.getOperand(3).getReg(), MRI, *TRI); - OpdsMapping[4] = getAGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI); + OpdsMapping[4] = + UseAGPRForm ? getAGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI) + : getVGPROpMapping(MI.getOperand(4).getReg(), MRI, *TRI); OpdsMapping[5] = getVGPROpMapping(MI.getOperand(5).getReg(), MRI, *TRI); break; } diff --git a/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp b/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp index ef63acc..71494be 100644 --- a/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp +++ b/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp @@ -905,7 +905,7 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) { OS << ":\n"; SlotIndex MBBStartSlot = LIS.getSlotIndexes()->getMBBStartIdx(&MBB); - SlotIndex MBBEndSlot = LIS.getSlotIndexes()->getMBBEndIdx(&MBB); + SlotIndex MBBLastSlot = LIS.getSlotIndexes()->getMBBLastIdx(&MBB); GCNRPTracker::LiveRegSet LiveIn, LiveOut; GCNRegPressure RPAtMBBEnd; @@ -931,7 +931,7 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) { } } else { GCNUpwardRPTracker RPT(LIS); - RPT.reset(MRI, MBBEndSlot); + RPT.reset(MRI, MBBLastSlot); LiveOut = RPT.getLiveRegs(); RPAtMBBEnd = RPT.getPressure(); @@ -966,14 +966,14 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) { OS << PFX " Live-out:" << llvm::print(LiveOut, MRI); if (UseDownwardTracker) - ReportLISMismatchIfAny(LiveOut, getLiveRegs(MBBEndSlot, LIS, MRI)); + ReportLISMismatchIfAny(LiveOut, getLiveRegs(MBBLastSlot, LIS, MRI)); GCNRPTracker::LiveRegSet LiveThrough; for (auto [Reg, Mask] : LiveIn) { LaneBitmask MaskIntersection = Mask & LiveOut.lookup(Reg); if (MaskIntersection.any()) { LaneBitmask LTMask = getRegLiveThroughMask( - MRI, LIS, Reg, MBBStartSlot, MBBEndSlot, MaskIntersection); + MRI, LIS, Reg, MBBStartSlot, MBBLastSlot, MaskIntersection); if (LTMask.any()) LiveThrough[Reg] = LTMask; } diff --git a/llvm/lib/Target/AMDGPU/GCNRegPressure.h b/llvm/lib/Target/AMDGPU/GCNRegPressure.h index a9c58bb..898d1ff 100644 --- a/llvm/lib/Target/AMDGPU/GCNRegPressure.h +++ b/llvm/lib/Target/AMDGPU/GCNRegPressure.h @@ -313,8 +313,8 @@ public: /// reset tracker to the end of the \p MBB. void reset(const MachineBasicBlock &MBB) { - reset(MBB.getParent()->getRegInfo(), - LIS.getSlotIndexes()->getMBBEndIdx(&MBB)); + SlotIndex MBBLastSlot = LIS.getSlotIndexes()->getMBBLastIdx(&MBB); + reset(MBB.getParent()->getRegInfo(), MBBLastSlot); } /// reset tracker to the point just after \p MI (in program order). diff --git a/llvm/lib/Target/AMDGPU/SIISelLowering.cpp b/llvm/lib/Target/AMDGPU/SIISelLowering.cpp index 730be69..80e985d 100644 --- a/llvm/lib/Target/AMDGPU/SIISelLowering.cpp +++ b/llvm/lib/Target/AMDGPU/SIISelLowering.cpp @@ -103,52 +103,52 @@ SITargetLowering::SITargetLowering(const TargetMachine &TM, addRegisterClass(MVT::Untyped, V64RegClass); addRegisterClass(MVT::v3i32, &AMDGPU::SGPR_96RegClass); - addRegisterClass(MVT::v3f32, TRI->getVGPRClassForBitWidth(96)); + addRegisterClass(MVT::v3f32, &AMDGPU::VReg_96RegClass); addRegisterClass(MVT::v2i64, &AMDGPU::SGPR_128RegClass); addRegisterClass(MVT::v2f64, &AMDGPU::SGPR_128RegClass); addRegisterClass(MVT::v4i32, &AMDGPU::SGPR_128RegClass); - addRegisterClass(MVT::v4f32, TRI->getVGPRClassForBitWidth(128)); + addRegisterClass(MVT::v4f32, &AMDGPU::VReg_128RegClass); addRegisterClass(MVT::v5i32, &AMDGPU::SGPR_160RegClass); - addRegisterClass(MVT::v5f32, TRI->getVGPRClassForBitWidth(160)); + addRegisterClass(MVT::v5f32, &AMDGPU::VReg_160RegClass); addRegisterClass(MVT::v6i32, &AMDGPU::SGPR_192RegClass); - addRegisterClass(MVT::v6f32, TRI->getVGPRClassForBitWidth(192)); + addRegisterClass(MVT::v6f32, &AMDGPU::VReg_192RegClass); addRegisterClass(MVT::v3i64, &AMDGPU::SGPR_192RegClass); - addRegisterClass(MVT::v3f64, TRI->getVGPRClassForBitWidth(192)); + addRegisterClass(MVT::v3f64, &AMDGPU::VReg_192RegClass); addRegisterClass(MVT::v7i32, &AMDGPU::SGPR_224RegClass); - addRegisterClass(MVT::v7f32, TRI->getVGPRClassForBitWidth(224)); + addRegisterClass(MVT::v7f32, &AMDGPU::VReg_224RegClass); addRegisterClass(MVT::v8i32, &AMDGPU::SGPR_256RegClass); - addRegisterClass(MVT::v8f32, TRI->getVGPRClassForBitWidth(256)); + addRegisterClass(MVT::v8f32, &AMDGPU::VReg_256RegClass); addRegisterClass(MVT::v4i64, &AMDGPU::SGPR_256RegClass); - addRegisterClass(MVT::v4f64, TRI->getVGPRClassForBitWidth(256)); + addRegisterClass(MVT::v4f64, &AMDGPU::VReg_256RegClass); addRegisterClass(MVT::v9i32, &AMDGPU::SGPR_288RegClass); - addRegisterClass(MVT::v9f32, TRI->getVGPRClassForBitWidth(288)); + addRegisterClass(MVT::v9f32, &AMDGPU::VReg_288RegClass); addRegisterClass(MVT::v10i32, &AMDGPU::SGPR_320RegClass); - addRegisterClass(MVT::v10f32, TRI->getVGPRClassForBitWidth(320)); + addRegisterClass(MVT::v10f32, &AMDGPU::VReg_320RegClass); addRegisterClass(MVT::v11i32, &AMDGPU::SGPR_352RegClass); - addRegisterClass(MVT::v11f32, TRI->getVGPRClassForBitWidth(352)); + addRegisterClass(MVT::v11f32, &AMDGPU::VReg_352RegClass); addRegisterClass(MVT::v12i32, &AMDGPU::SGPR_384RegClass); - addRegisterClass(MVT::v12f32, TRI->getVGPRClassForBitWidth(384)); + addRegisterClass(MVT::v12f32, &AMDGPU::VReg_384RegClass); addRegisterClass(MVT::v16i32, &AMDGPU::SGPR_512RegClass); - addRegisterClass(MVT::v16f32, TRI->getVGPRClassForBitWidth(512)); + addRegisterClass(MVT::v16f32, &AMDGPU::VReg_512RegClass); addRegisterClass(MVT::v8i64, &AMDGPU::SGPR_512RegClass); - addRegisterClass(MVT::v8f64, TRI->getVGPRClassForBitWidth(512)); + addRegisterClass(MVT::v8f64, &AMDGPU::VReg_512RegClass); addRegisterClass(MVT::v16i64, &AMDGPU::SGPR_1024RegClass); - addRegisterClass(MVT::v16f64, TRI->getVGPRClassForBitWidth(1024)); + addRegisterClass(MVT::v16f64, &AMDGPU::VReg_1024RegClass); if (Subtarget->has16BitInsts()) { if (Subtarget->useRealTrue16Insts()) { @@ -180,7 +180,7 @@ SITargetLowering::SITargetLowering(const TargetMachine &TM, } addRegisterClass(MVT::v32i32, &AMDGPU::VReg_1024RegClass); - addRegisterClass(MVT::v32f32, TRI->getVGPRClassForBitWidth(1024)); + addRegisterClass(MVT::v32f32, &AMDGPU::VReg_1024RegClass); computeRegisterProperties(Subtarget->getRegisterInfo()); diff --git a/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h b/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h index b7dbb59..2c1a13c 100644 --- a/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h +++ b/llvm/lib/Target/AMDGPU/SIMachineFunctionInfo.h @@ -1202,6 +1202,12 @@ public: unsigned getMinNumAGPRs() const { return MinNumAGPRs; } + /// Return true if an MFMA that requires at least \p NumRegs should select to + /// the AGPR form, instead of the VGPR form. + bool selectAGPRFormMFMA(unsigned NumRegs) const { + return !MFMAVGPRForm && getMinNumAGPRs() >= NumRegs; + } + // \returns true if a function has a use of AGPRs via inline asm or // has a call which may use it. bool mayUseAGPRs(const Function &F) const; diff --git a/llvm/lib/Target/AMDGPU/VOP3PInstructions.td b/llvm/lib/Target/AMDGPU/VOP3PInstructions.td index 7cfd059..6500fce 100644 --- a/llvm/lib/Target/AMDGPU/VOP3PInstructions.td +++ b/llvm/lib/Target/AMDGPU/VOP3PInstructions.td @@ -964,14 +964,12 @@ class MAIFrag<SDPatternOperator Op, bit HasAbid = true, bit Scaled = false> : Pa class CanUseAGPR_MAI<ValueType vt> { code PredicateCode = [{ return !Subtarget->hasGFX90AInsts() || - (!SIMachineFunctionInfo::MFMAVGPRForm && - MF->getInfo<SIMachineFunctionInfo>()->getMinNumAGPRs() >= - }] # !srl(vt.Size, 5) # ");"; + MF->getInfo<SIMachineFunctionInfo>()->selectAGPRFormMFMA( + }] # !srl(vt.Size, 5) # ");"; code GISelPredicateCode = [{ return !Subtarget->hasGFX90AInsts() || - (!SIMachineFunctionInfo::MFMAVGPRForm && - MF.getInfo<SIMachineFunctionInfo>()->getMinNumAGPRs() >= + MF.getInfo<SIMachineFunctionInfo>()->selectAGPRFormMFMA( }] # !srl(vt.Size, 5) # ");"; } diff --git a/llvm/lib/Target/ARM/ARMISelLowering.cpp b/llvm/lib/Target/ARM/ARMISelLowering.cpp index 2a40fb9..83c7def 100644 --- a/llvm/lib/Target/ARM/ARMISelLowering.cpp +++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp @@ -42,7 +42,6 @@ #include "llvm/CodeGen/CallingConvLower.h" #include "llvm/CodeGen/ComplexDeinterleavingPass.h" #include "llvm/CodeGen/ISDOpcodes.h" -#include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/CodeGen/MachineBasicBlock.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineFrameInfo.h" diff --git a/llvm/lib/Target/Hexagon/HexagonPatterns.td b/llvm/lib/Target/Hexagon/HexagonPatterns.td index a0acfcf..85ce944 100644 --- a/llvm/lib/Target/Hexagon/HexagonPatterns.td +++ b/llvm/lib/Target/Hexagon/HexagonPatterns.td @@ -699,35 +699,20 @@ def: OpR_RR_pat<C2_cmpgtp, setgt, i1, I64>; def: OpR_RR_pat<C2_cmpgtup, setugt, i1, I64>; def: OpR_RR_pat<C2_cmpgtp, RevCmp<setlt>, i1, I64>; def: OpR_RR_pat<C2_cmpgtup, RevCmp<setult>, i1, I64>; -def: OpR_RR_pat<A2_vcmpbeq, seteq, i1, V8I8>; def: OpR_RR_pat<A2_vcmpbeq, seteq, v8i1, V8I8>; -def: OpR_RR_pat<A4_vcmpbgt, RevCmp<setlt>, i1, V8I8>; def: OpR_RR_pat<A4_vcmpbgt, RevCmp<setlt>, v8i1, V8I8>; -def: OpR_RR_pat<A4_vcmpbgt, setgt, i1, V8I8>; def: OpR_RR_pat<A4_vcmpbgt, setgt, v8i1, V8I8>; -def: OpR_RR_pat<A2_vcmpbgtu, RevCmp<setult>, i1, V8I8>; def: OpR_RR_pat<A2_vcmpbgtu, RevCmp<setult>, v8i1, V8I8>; -def: OpR_RR_pat<A2_vcmpbgtu, setugt, i1, V8I8>; def: OpR_RR_pat<A2_vcmpbgtu, setugt, v8i1, V8I8>; -def: OpR_RR_pat<A2_vcmpheq, seteq, i1, V4I16>; def: OpR_RR_pat<A2_vcmpheq, seteq, v4i1, V4I16>; -def: OpR_RR_pat<A2_vcmphgt, RevCmp<setlt>, i1, V4I16>; def: OpR_RR_pat<A2_vcmphgt, RevCmp<setlt>, v4i1, V4I16>; -def: OpR_RR_pat<A2_vcmphgt, setgt, i1, V4I16>; def: OpR_RR_pat<A2_vcmphgt, setgt, v4i1, V4I16>; -def: OpR_RR_pat<A2_vcmphgtu, RevCmp<setult>, i1, V4I16>; def: OpR_RR_pat<A2_vcmphgtu, RevCmp<setult>, v4i1, V4I16>; -def: OpR_RR_pat<A2_vcmphgtu, setugt, i1, V4I16>; def: OpR_RR_pat<A2_vcmphgtu, setugt, v4i1, V4I16>; -def: OpR_RR_pat<A2_vcmpweq, seteq, i1, V2I32>; def: OpR_RR_pat<A2_vcmpweq, seteq, v2i1, V2I32>; -def: OpR_RR_pat<A2_vcmpwgt, RevCmp<setlt>, i1, V2I32>; def: OpR_RR_pat<A2_vcmpwgt, RevCmp<setlt>, v2i1, V2I32>; -def: OpR_RR_pat<A2_vcmpwgt, setgt, i1, V2I32>; def: OpR_RR_pat<A2_vcmpwgt, setgt, v2i1, V2I32>; -def: OpR_RR_pat<A2_vcmpwgtu, RevCmp<setult>, i1, V2I32>; def: OpR_RR_pat<A2_vcmpwgtu, RevCmp<setult>, v2i1, V2I32>; -def: OpR_RR_pat<A2_vcmpwgtu, setugt, i1, V2I32>; def: OpR_RR_pat<A2_vcmpwgtu, setugt, v2i1, V2I32>; def: OpR_RR_pat<F2_sfcmpeq, seteq, i1, F32>; @@ -1213,12 +1198,6 @@ def: OpR_RI_pat<S2_asl_i_r, Shl, i32, I32, u5_0ImmPred>; def: OpR_RI_pat<S2_asr_i_p, Sra, i64, I64, u6_0ImmPred>; def: OpR_RI_pat<S2_lsr_i_p, Srl, i64, I64, u6_0ImmPred>; def: OpR_RI_pat<S2_asl_i_p, Shl, i64, I64, u6_0ImmPred>; -def: OpR_RI_pat<S2_asr_i_vh, Sra, v4i16, V4I16, u4_0ImmPred>; -def: OpR_RI_pat<S2_lsr_i_vh, Srl, v4i16, V4I16, u4_0ImmPred>; -def: OpR_RI_pat<S2_asl_i_vh, Shl, v4i16, V4I16, u4_0ImmPred>; -def: OpR_RI_pat<S2_asr_i_vh, Sra, v2i32, V2I32, u5_0ImmPred>; -def: OpR_RI_pat<S2_lsr_i_vh, Srl, v2i32, V2I32, u5_0ImmPred>; -def: OpR_RI_pat<S2_asl_i_vh, Shl, v2i32, V2I32, u5_0ImmPred>; def: OpR_RR_pat<S2_asr_r_r, Sra, i32, I32, I32>; def: OpR_RR_pat<S2_lsr_r_r, Srl, i32, I32, I32>; diff --git a/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp b/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp index ba70c9e..97379d7 100644 --- a/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp +++ b/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp @@ -3677,7 +3677,7 @@ bool MipsAsmParser::expandBranchImm(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out, Out, STI)) return true; - if (IsLikely) { + if (IsLikely && MemOffsetOp.isExpr()) { TOut.emitRRX(OpCode, DstRegOp.getReg(), ATReg, MCOperand::createExpr(MemOffsetOp.getExpr()), IDLoc, STI); TOut.emitRRI(Mips::SLL, Mips::ZERO, Mips::ZERO, 0, IDLoc, STI); diff --git a/llvm/lib/Target/Mips/MipsInstrInfo.td b/llvm/lib/Target/Mips/MipsInstrInfo.td index eff80e5..21d8ded 100644 --- a/llvm/lib/Target/Mips/MipsInstrInfo.td +++ b/llvm/lib/Target/Mips/MipsInstrInfo.td @@ -855,6 +855,16 @@ def calltarget : Operand<iPTR> { def imm64: Operand<i64>; +def ConstantImmAsmOperandClass : AsmOperandClass { + let Name = "ConstantImm"; + let PredicateMethod = "isConstantImm"; + let RenderMethod = "addImmOperands"; +} + +def ConstantImm64: Operand<i64> { + let ParserMatchClass = ConstantImmAsmOperandClass; +} + def simm19_lsl2 : Operand<i32> { let EncoderMethod = "getSimm19Lsl2Encoding"; let DecoderMethod = "DecodeSimm19Lsl2"; @@ -2947,10 +2957,10 @@ def : MipsInstAlias<"nor\t$rs, $imm", (NORImm GPR32Opnd:$rs, GPR32Opnd:$rs, let hasDelaySlot = 1, isCTI = 1 in { def BneImm : MipsAsmPseudoInst<(outs GPR32Opnd:$rt), - (ins imm64:$imm64, brtarget:$offset), + (ins ConstantImm64:$imm64, brtarget:$offset), "bne\t$rt, $imm64, $offset">; def BeqImm : MipsAsmPseudoInst<(outs GPR32Opnd:$rt), - (ins imm64:$imm64, brtarget:$offset), + (ins ConstantImm64:$imm64, brtarget:$offset), "beq\t$rt, $imm64, $offset">; class CondBranchPseudo<string instr_asm> : @@ -2978,7 +2988,7 @@ def BGTUL: CondBranchPseudo<"bgtul">, ISA_MIPS2_NOT_32R6_64R6; let isCTI = 1 in class CondBranchImmPseudo<string instr_asm> : - MipsAsmPseudoInst<(outs), (ins GPR32Opnd:$rs, imm64:$imm, brtarget:$offset), + MipsAsmPseudoInst<(outs), (ins GPR32Opnd:$rs, ConstantImm64:$imm, brtarget:$offset), !strconcat(instr_asm, "\t$rs, $imm, $offset")>; def BEQLImmMacro : CondBranchImmPseudo<"beql">, ISA_MIPS2_NOT_32R6_64R6; diff --git a/llvm/lib/Target/RISCV/RISCVFeatures.td b/llvm/lib/Target/RISCV/RISCVFeatures.td index 333b693..5ceb477 100644 --- a/llvm/lib/Target/RISCV/RISCVFeatures.td +++ b/llvm/lib/Target/RISCV/RISCVFeatures.td @@ -1520,6 +1520,8 @@ def HasVendorXqcics : Predicate<"Subtarget->hasVendorXqcics()">, AssemblerPredicate<(all_of FeatureVendorXqcics), "'Xqcics' (Qualcomm uC Conditional Select Extension)">; +def NoVendorXqcics + : Predicate<"!Subtarget->hasVendorXqcics()">; def FeatureVendorXqcicsr : RISCVExperimentalExtension<0, 4, "Qualcomm uC CSR Extension">; diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td b/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td index f2724c41..5e1d07a 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td @@ -1571,35 +1571,42 @@ def : QCIMVCCIPat<SETUGE, QC_MVGEUI, uimm5nonzero>; } let Predicates = [HasVendorXqcicli, IsRV32] in { -def : QCILICCPat<SETEQ, QC_LIEQ>; -def : QCILICCPat<SETNE, QC_LINE>; def : QCILICCPat<SETLT, QC_LILT>; def : QCILICCPat<SETGE, QC_LIGE>; def : QCILICCPat<SETULT, QC_LILTU>; def : QCILICCPat<SETUGE, QC_LIGEU>; -def : QCILICCIPat<SETEQ, QC_LIEQI, simm5>; -def : QCILICCIPat<SETNE, QC_LINEI, simm5>; def : QCILICCIPat<SETLT, QC_LILTI, simm5>; def : QCILICCIPat<SETGE, QC_LIGEI, simm5>; def : QCILICCIPat<SETULT, QC_LILTUI, uimm5>; def : QCILICCIPat<SETUGE, QC_LIGEUI, uimm5>; -def : QCILICCPatInv<SETNE, QC_LIEQ>; -def : QCILICCPatInv<SETEQ, QC_LINE>; def : QCILICCPatInv<SETGE, QC_LILT>; def : QCILICCPatInv<SETLT, QC_LIGE>; def : QCILICCPatInv<SETUGE, QC_LILTU>; def : QCILICCPatInv<SETULT, QC_LIGEU>; -def : QCILICCIPatInv<SETNE, QC_LIEQI, simm5>; -def : QCILICCIPatInv<SETEQ, QC_LINEI, simm5>; def : QCILICCIPatInv<SETGE, QC_LILTI, simm5>; def : QCILICCIPatInv<SETLT, QC_LIGEI, simm5>; def : QCILICCIPatInv<SETUGE, QC_LILTUI, uimm5>; def : QCILICCIPatInv<SETULT, QC_LIGEUI, uimm5>; } // Predicates = [HasVendorXqcicli, IsRV32] +// Prioritize Xqcics over these patterns. +let Predicates = [HasVendorXqcicli, NoVendorXqcics, IsRV32] in { +def : QCILICCPat<SETEQ, QC_LIEQ>; +def : QCILICCPat<SETNE, QC_LINE>; + +def : QCILICCIPat<SETEQ, QC_LIEQI, simm5>; +def : QCILICCIPat<SETNE, QC_LINEI, simm5>; + +def : QCILICCPatInv<SETNE, QC_LIEQ>; +def : QCILICCPatInv<SETEQ, QC_LINE>; + +def : QCILICCIPatInv<SETNE, QC_LIEQI, simm5>; +def : QCILICCIPatInv<SETEQ, QC_LINEI, simm5>; +} // Predicates = [HasVendorXqcicli, NoVendorXqcics, IsRV32] + let Predicates = [HasVendorXqcics, IsRV32] in { // (SELECT X, Y, Z) is canonicalised to `(riscv_selectcc x, 0, NE, y, z)`. // These exist to prioritise over the `Select_GPR_Using_CC_GPR` pattern. diff --git a/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp b/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp index e8c849e..28a1690 100644 --- a/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp +++ b/llvm/lib/Target/SPIRV/SPIRVLegalizePointerCast.cpp @@ -46,7 +46,6 @@ #include "SPIRVSubtarget.h" #include "SPIRVTargetMachine.h" #include "SPIRVUtils.h" -#include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/Intrinsics.h" diff --git a/llvm/lib/Target/SPIRV/SPIRVMergeRegionExitTargets.cpp b/llvm/lib/Target/SPIRV/SPIRVMergeRegionExitTargets.cpp index 20f03b0..60d39c9 100644 --- a/llvm/lib/Target/SPIRV/SPIRVMergeRegionExitTargets.cpp +++ b/llvm/lib/Target/SPIRV/SPIRVMergeRegionExitTargets.cpp @@ -19,7 +19,6 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/Analysis/LoopInfo.h" -#include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Intrinsics.h" diff --git a/llvm/lib/Target/SPIRV/SPIRVStripConvergentIntrinsics.cpp b/llvm/lib/Target/SPIRV/SPIRVStripConvergentIntrinsics.cpp index 278ad7c..e621bcd44 100644 --- a/llvm/lib/Target/SPIRV/SPIRVStripConvergentIntrinsics.cpp +++ b/llvm/lib/Target/SPIRV/SPIRVStripConvergentIntrinsics.cpp @@ -14,7 +14,6 @@ #include "SPIRV.h" #include "SPIRVSubtarget.h" #include "SPIRVUtils.h" -#include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Transforms/Utils/Cloning.h" diff --git a/llvm/lib/Target/SPIRV/SPIRVStructurizer.cpp b/llvm/lib/Target/SPIRV/SPIRVStructurizer.cpp index 1811492..5b149f8 100644 --- a/llvm/lib/Target/SPIRV/SPIRVStructurizer.cpp +++ b/llvm/lib/Target/SPIRV/SPIRVStructurizer.cpp @@ -16,7 +16,6 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/Analysis/LoopInfo.h" -#include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/IR/CFG.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/IRBuilder.h" diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp index 9580ade..1cfcb1f 100644 --- a/llvm/lib/Target/X86/X86ISelLowering.cpp +++ b/llvm/lib/Target/X86/X86ISelLowering.cpp @@ -28,7 +28,6 @@ #include "llvm/Analysis/BlockFrequencyInfo.h" #include "llvm/Analysis/ProfileSummaryInfo.h" #include "llvm/Analysis/VectorUtils.h" -#include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/CodeGen/LivePhysRegs.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineFunction.h" diff --git a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp index 3bc46af..6dd43b2 100644 --- a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp +++ b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp @@ -547,7 +547,7 @@ unsigned X86TargetLowering::getAddressSpace() const { static bool hasStackGuardSlotTLS(const Triple &TargetTriple) { return TargetTriple.isOSGlibc() || TargetTriple.isOSFuchsia() || - (TargetTriple.isAndroid() && !TargetTriple.isAndroidVersionLT(17)); + TargetTriple.isAndroid(); } static Constant* SegmentOffset(IRBuilderBase &IRB, diff --git a/llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp b/llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp index cfdfd94..5066a99 100644 --- a/llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp +++ b/llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp @@ -1033,19 +1033,17 @@ private: }; } // namespace -namespace llvm { template <> -struct DenseMapInfo<typename CallsiteContextGraph< +struct llvm::DenseMapInfo<typename CallsiteContextGraph< ModuleCallsiteContextGraph, Function, Instruction *>::CallInfo> : public DenseMapInfo<std::pair<Instruction *, unsigned>> {}; template <> -struct DenseMapInfo<typename CallsiteContextGraph< +struct llvm::DenseMapInfo<typename CallsiteContextGraph< IndexCallsiteContextGraph, FunctionSummary, IndexCall>::CallInfo> : public DenseMapInfo<std::pair<IndexCall, unsigned>> {}; template <> -struct DenseMapInfo<IndexCall> +struct llvm::DenseMapInfo<IndexCall> : public DenseMapInfo<PointerUnion<CallsiteInfo *, AllocInfo *>> {}; -} // end namespace llvm namespace { diff --git a/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp b/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp index ac41fdd..2d5cb82 100644 --- a/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp +++ b/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp @@ -372,9 +372,7 @@ struct VTableSlot { } // end anonymous namespace -namespace llvm { - -template <> struct DenseMapInfo<VTableSlot> { +template <> struct llvm::DenseMapInfo<VTableSlot> { static VTableSlot getEmptyKey() { return {DenseMapInfo<Metadata *>::getEmptyKey(), DenseMapInfo<uint64_t>::getEmptyKey()}; @@ -393,7 +391,7 @@ template <> struct DenseMapInfo<VTableSlot> { } }; -template <> struct DenseMapInfo<VTableSlotSummary> { +template <> struct llvm::DenseMapInfo<VTableSlotSummary> { static VTableSlotSummary getEmptyKey() { return {DenseMapInfo<StringRef>::getEmptyKey(), DenseMapInfo<uint64_t>::getEmptyKey()}; @@ -412,8 +410,6 @@ template <> struct DenseMapInfo<VTableSlotSummary> { } }; -} // end namespace llvm - // Returns true if the function must be unreachable based on ValueInfo. // // In particular, identifies a function as unreachable in the following diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp index 9b272c4..3ddf182 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp @@ -28,6 +28,10 @@ using namespace PatternMatch; #define DEBUG_TYPE "instcombine" +namespace llvm { +extern cl::opt<bool> ProfcheckDisableMetadataFixes; +} + /// This is the complement of getICmpCode, which turns an opcode and two /// operands into either a constant true or false, or a brand new ICmp /// instruction. The sign is passed in to determine which kind of predicate to @@ -1272,7 +1276,8 @@ Value *InstCombinerImpl::foldEqOfParts(Value *Cmp0, Value *Cmp1, bool IsAnd) { static Value *foldAndOrOfICmpsWithConstEq(ICmpInst *Cmp0, ICmpInst *Cmp1, bool IsAnd, bool IsLogical, InstCombiner::BuilderTy &Builder, - const SimplifyQuery &Q) { + const SimplifyQuery &Q, + Instruction &I) { // Match an equality compare with a non-poison constant as Cmp0. // Also, give up if the compare can be constant-folded to avoid looping. CmpPredicate Pred0; @@ -1306,9 +1311,12 @@ static Value *foldAndOrOfICmpsWithConstEq(ICmpInst *Cmp0, ICmpInst *Cmp1, return nullptr; SubstituteCmp = Builder.CreateICmp(Pred1, Y, C); } - if (IsLogical) - return IsAnd ? Builder.CreateLogicalAnd(Cmp0, SubstituteCmp) - : Builder.CreateLogicalOr(Cmp0, SubstituteCmp); + if (IsLogical) { + Instruction *MDFrom = + ProfcheckDisableMetadataFixes && isa<SelectInst>(I) ? nullptr : &I; + return IsAnd ? Builder.CreateLogicalAnd(Cmp0, SubstituteCmp, "", MDFrom) + : Builder.CreateLogicalOr(Cmp0, SubstituteCmp, "", MDFrom); + } return Builder.CreateBinOp(IsAnd ? Instruction::And : Instruction::Or, Cmp0, SubstituteCmp); } @@ -3396,13 +3404,13 @@ Value *InstCombinerImpl::foldAndOrOfICmps(ICmpInst *LHS, ICmpInst *RHS, /*IsLogical*/ false, Builder)) return V; - if (Value *V = - foldAndOrOfICmpsWithConstEq(LHS, RHS, IsAnd, IsLogical, Builder, Q)) + if (Value *V = foldAndOrOfICmpsWithConstEq(LHS, RHS, IsAnd, IsLogical, + Builder, Q, I)) return V; // We can convert this case to bitwise and, because both operands are used // on the LHS, and as such poison from both will propagate. - if (Value *V = foldAndOrOfICmpsWithConstEq(RHS, LHS, IsAnd, - /*IsLogical=*/false, Builder, Q)) { + if (Value *V = foldAndOrOfICmpsWithConstEq( + RHS, LHS, IsAnd, /*IsLogical=*/false, Builder, Q, I)) { // If RHS is still used, we should drop samesign flag. if (IsLogical && RHS->hasSameSign() && !RHS->use_empty()) { RHS->setSameSign(false); diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp index 56194fe..4c9b10a 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp @@ -2202,6 +2202,11 @@ Instruction *InstCombinerImpl::visitPtrToInt(PtrToIntInst &CI) { return commonCastTransforms(CI); } +Instruction *InstCombinerImpl::visitPtrToAddr(PtrToAddrInst &CI) { + // FIXME: Implement variants of ptrtoint folds. + return commonCastTransforms(CI); +} + /// This input value (which is known to have vector type) is being zero extended /// or truncated to the specified vector type. Since the zext/trunc is done /// using an integer type, we have a (bitcast(cast(bitcast))) pattern, diff --git a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h index e01c145..218aaf9 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h +++ b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h @@ -143,6 +143,7 @@ public: Instruction *visitUIToFP(CastInst &CI); Instruction *visitSIToFP(CastInst &CI); Instruction *visitPtrToInt(PtrToIntInst &CI); + Instruction *visitPtrToAddr(PtrToAddrInst &CI); Instruction *visitIntToPtr(IntToPtrInst &CI); Instruction *visitBitCast(BitCastInst &CI); Instruction *visitAddrSpaceCast(AddrSpaceCastInst &CI); diff --git a/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp b/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp index 5c747bb..9815644 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp @@ -1069,27 +1069,22 @@ struct LoweredPHIRecord { }; } // namespace -namespace llvm { - template<> - struct DenseMapInfo<LoweredPHIRecord> { - static inline LoweredPHIRecord getEmptyKey() { - return LoweredPHIRecord(nullptr, 0); - } - static inline LoweredPHIRecord getTombstoneKey() { - return LoweredPHIRecord(nullptr, 1); - } - static unsigned getHashValue(const LoweredPHIRecord &Val) { - return DenseMapInfo<PHINode*>::getHashValue(Val.PN) ^ (Val.Shift>>3) ^ - (Val.Width>>3); - } - static bool isEqual(const LoweredPHIRecord &LHS, - const LoweredPHIRecord &RHS) { - return LHS.PN == RHS.PN && LHS.Shift == RHS.Shift && - LHS.Width == RHS.Width; - } - }; -} // namespace llvm - +template <> struct llvm::DenseMapInfo<LoweredPHIRecord> { + static inline LoweredPHIRecord getEmptyKey() { + return LoweredPHIRecord(nullptr, 0); + } + static inline LoweredPHIRecord getTombstoneKey() { + return LoweredPHIRecord(nullptr, 1); + } + static unsigned getHashValue(const LoweredPHIRecord &Val) { + return DenseMapInfo<PHINode *>::getHashValue(Val.PN) ^ (Val.Shift >> 3) ^ + (Val.Width >> 3); + } + static bool isEqual(const LoweredPHIRecord &LHS, + const LoweredPHIRecord &RHS) { + return LHS.PN == RHS.PN && LHS.Shift == RHS.Shift && LHS.Width == RHS.Width; + } +}; /// This is an integer PHI and we know that it has an illegal type: see if it is /// only used by trunc or trunc(lshr) operations. If so, we split the PHI into diff --git a/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp index 3704ad7..860f8f7 100644 --- a/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp @@ -600,9 +600,7 @@ static ShadowMapping getShadowMapping(const Triple &TargetTriple, int LongSize, !IsRISCV64 && !IsLoongArch64 && !(Mapping.Offset & (Mapping.Offset - 1)) && Mapping.Offset != kDynamicShadowSentinel; - bool IsAndroidWithIfuncSupport = - IsAndroid && !TargetTriple.isAndroidVersionLT(21); - Mapping.InGlobal = ClWithIfunc && IsAndroidWithIfuncSupport && IsArmOrThumb; + Mapping.InGlobal = ClWithIfunc && IsAndroid && IsArmOrThumb; return Mapping; } diff --git a/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp b/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp index 3f7003d..e5935f4 100644 --- a/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp +++ b/llvm/lib/Transforms/Scalar/DFAJumpThreading.cpp @@ -148,19 +148,16 @@ public: class DFAJumpThreading { public: - DFAJumpThreading(AssumptionCache *AC, DominatorTree *DT, LoopInfo *LI, + DFAJumpThreading(AssumptionCache *AC, DomTreeUpdater *DTU, LoopInfo *LI, TargetTransformInfo *TTI, OptimizationRemarkEmitter *ORE) - : AC(AC), DT(DT), LI(LI), TTI(TTI), ORE(ORE) {} + : AC(AC), DTU(DTU), LI(LI), TTI(TTI), ORE(ORE) {} bool run(Function &F); bool LoopInfoBroken; private: void - unfoldSelectInstrs(DominatorTree *DT, - const SmallVector<SelectInstToUnfold, 4> &SelectInsts) { - // TODO: Have everything use a single lazy DTU - DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy); + unfoldSelectInstrs(const SmallVector<SelectInstToUnfold, 4> &SelectInsts) { SmallVector<SelectInstToUnfold, 4> Stack(SelectInsts); while (!Stack.empty()) { @@ -168,7 +165,7 @@ private: std::vector<SelectInstToUnfold> NewSIsToUnfold; std::vector<BasicBlock *> NewBBs; - unfold(&DTU, LI, SIToUnfold, &NewSIsToUnfold, &NewBBs); + unfold(DTU, LI, SIToUnfold, &NewSIsToUnfold, &NewBBs); // Put newly discovered select instructions into the work list. llvm::append_range(Stack, NewSIsToUnfold); @@ -181,7 +178,7 @@ private: std::vector<BasicBlock *> *NewBBs); AssumptionCache *AC; - DominatorTree *DT; + DomTreeUpdater *DTU; LoopInfo *LI; TargetTransformInfo *TTI; OptimizationRemarkEmitter *ORE; @@ -389,6 +386,22 @@ inline raw_ostream &operator<<(raw_ostream &OS, const PathType &Path) { return OS; } +/// Helper to get the successor corresponding to a particular case value for +/// a switch statement. +static BasicBlock *getNextCaseSuccessor(SwitchInst *Switch, + const APInt &NextState) { + BasicBlock *NextCase = nullptr; + for (auto Case : Switch->cases()) { + if (Case.getCaseValue()->getValue() == NextState) { + NextCase = Case.getCaseSuccessor(); + break; + } + } + if (!NextCase) + NextCase = Switch->getDefaultDest(); + return NextCase; +} + namespace { /// ThreadingPath is a path in the control flow of a loop that can be threaded /// by cloning necessary basic blocks and replacing conditional branches with @@ -401,6 +414,10 @@ struct ThreadingPath { ExitVal = V->getValue(); IsExitValSet = true; } + void setExitValue(const APInt &V) { + ExitVal = V; + IsExitValSet = true; + } bool isExitValueSet() const { return IsExitValSet; } /// Determinator is the basic block that determines the next state of the DFA. @@ -583,44 +600,8 @@ struct AllSwitchPaths { BasicBlock *getSwitchBlock() { return SwitchBlock; } void run() { - StateDefMap StateDef = getStateDefMap(); - if (StateDef.empty()) { - ORE->emit([&]() { - return OptimizationRemarkMissed(DEBUG_TYPE, "SwitchNotPredictable", - Switch) - << "Switch instruction is not predictable."; - }); - return; - } - - auto *SwitchPhi = cast<PHINode>(Switch->getOperand(0)); - auto *SwitchPhiDefBB = SwitchPhi->getParent(); - VisitedBlocks VB; - // Get paths from the determinator BBs to SwitchPhiDefBB - std::vector<ThreadingPath> PathsToPhiDef = - getPathsFromStateDefMap(StateDef, SwitchPhi, VB, MaxNumPaths); - if (SwitchPhiDefBB == SwitchBlock || PathsToPhiDef.empty()) { - TPaths = std::move(PathsToPhiDef); - return; - } - - assert(MaxNumPaths >= PathsToPhiDef.size() && !PathsToPhiDef.empty()); - auto PathsLimit = MaxNumPaths / PathsToPhiDef.size(); - // Find and append paths from SwitchPhiDefBB to SwitchBlock. - PathsType PathsToSwitchBB = - paths(SwitchPhiDefBB, SwitchBlock, VB, /* PathDepth = */ 1, PathsLimit); - if (PathsToSwitchBB.empty()) - return; - - std::vector<ThreadingPath> TempList; - for (const ThreadingPath &Path : PathsToPhiDef) { - for (const PathType &PathToSw : PathsToSwitchBB) { - ThreadingPath PathCopy(Path); - PathCopy.appendExcludingFirst(PathToSw); - TempList.push_back(PathCopy); - } - } - TPaths = std::move(TempList); + findTPaths(); + unifyTPaths(); } private: @@ -812,6 +793,69 @@ private: return Res; } + // Find all threadable paths. + void findTPaths() { + StateDefMap StateDef = getStateDefMap(); + if (StateDef.empty()) { + ORE->emit([&]() { + return OptimizationRemarkMissed(DEBUG_TYPE, "SwitchNotPredictable", + Switch) + << "Switch instruction is not predictable."; + }); + return; + } + + auto *SwitchPhi = cast<PHINode>(Switch->getOperand(0)); + auto *SwitchPhiDefBB = SwitchPhi->getParent(); + VisitedBlocks VB; + // Get paths from the determinator BBs to SwitchPhiDefBB + std::vector<ThreadingPath> PathsToPhiDef = + getPathsFromStateDefMap(StateDef, SwitchPhi, VB, MaxNumPaths); + if (SwitchPhiDefBB == SwitchBlock || PathsToPhiDef.empty()) { + TPaths = std::move(PathsToPhiDef); + return; + } + + assert(MaxNumPaths >= PathsToPhiDef.size() && !PathsToPhiDef.empty()); + auto PathsLimit = MaxNumPaths / PathsToPhiDef.size(); + // Find and append paths from SwitchPhiDefBB to SwitchBlock. + PathsType PathsToSwitchBB = + paths(SwitchPhiDefBB, SwitchBlock, VB, /* PathDepth = */ 1, PathsLimit); + if (PathsToSwitchBB.empty()) + return; + + std::vector<ThreadingPath> TempList; + for (const ThreadingPath &Path : PathsToPhiDef) { + for (const PathType &PathToSw : PathsToSwitchBB) { + ThreadingPath PathCopy(Path); + PathCopy.appendExcludingFirst(PathToSw); + TempList.push_back(PathCopy); + } + } + TPaths = std::move(TempList); + } + + // Two states are equivalent if they have the same switch destination. + // Unify the states in different threading path if the states are equivalent. + void unifyTPaths() { + llvm::SmallDenseMap<BasicBlock *, APInt> DestToState; + for (ThreadingPath &Path : TPaths) { + APInt NextState = Path.getExitValue(); + BasicBlock *Dest = getNextCaseSuccessor(Switch, NextState); + auto StateIt = DestToState.find(Dest); + if (StateIt == DestToState.end()) { + DestToState.insert({Dest, NextState}); + continue; + } + + if (NextState != StateIt->second) { + LLVM_DEBUG(dbgs() << "Next state in " << Path << " is equivalent to " + << StateIt->second << "\n"); + Path.setExitValue(StateIt->second); + } + } + } + unsigned NumVisited = 0; SwitchInst *Switch; BasicBlock *SwitchBlock; @@ -822,11 +866,11 @@ private: }; struct TransformDFA { - TransformDFA(AllSwitchPaths *SwitchPaths, DominatorTree *DT, + TransformDFA(AllSwitchPaths *SwitchPaths, DomTreeUpdater *DTU, AssumptionCache *AC, TargetTransformInfo *TTI, OptimizationRemarkEmitter *ORE, SmallPtrSet<const Value *, 32> EphValues) - : SwitchPaths(SwitchPaths), DT(DT), AC(AC), TTI(TTI), ORE(ORE), + : SwitchPaths(SwitchPaths), DTU(DTU), AC(AC), TTI(TTI), ORE(ORE), EphValues(EphValues) {} bool run() { @@ -1002,19 +1046,16 @@ private: SmallPtrSet<BasicBlock *, 16> BlocksToClean; BlocksToClean.insert_range(successors(SwitchBlock)); - { - DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Lazy); - for (const ThreadingPath &TPath : SwitchPaths->getThreadingPaths()) { - createExitPath(NewDefs, TPath, DuplicateMap, BlocksToClean, &DTU); - NumPaths++; - } - - // After all paths are cloned, now update the last successor of the cloned - // path so it skips over the switch statement - for (const ThreadingPath &TPath : SwitchPaths->getThreadingPaths()) - updateLastSuccessor(TPath, DuplicateMap, &DTU); + for (const ThreadingPath &TPath : SwitchPaths->getThreadingPaths()) { + createExitPath(NewDefs, TPath, DuplicateMap, BlocksToClean, DTU); + NumPaths++; } + // After all paths are cloned, now update the last successor of the cloned + // path so it skips over the switch statement + for (const ThreadingPath &TPath : SwitchPaths->getThreadingPaths()) + updateLastSuccessor(TPath, DuplicateMap, DTU); + // For each instruction that was cloned and used outside, update its uses updateSSA(NewDefs); @@ -1118,7 +1159,7 @@ private: } // SSAUpdater handles phi placement and renaming uses with the appropriate // value. - SSAUpdate.RewriteAllUses(DT); + SSAUpdate.RewriteAllUses(&DTU->getDomTree()); } /// Clones a basic block, and adds it to the CFG. @@ -1335,28 +1376,13 @@ private: return It != ClonedBBs.end() ? (*It).BB : nullptr; } - /// Helper to get the successor corresponding to a particular case value for - /// a switch statement. - BasicBlock *getNextCaseSuccessor(SwitchInst *Switch, const APInt &NextState) { - BasicBlock *NextCase = nullptr; - for (auto Case : Switch->cases()) { - if (Case.getCaseValue()->getValue() == NextState) { - NextCase = Case.getCaseSuccessor(); - break; - } - } - if (!NextCase) - NextCase = Switch->getDefaultDest(); - return NextCase; - } - /// Returns true if IncomingBB is a predecessor of BB. bool isPredecessor(BasicBlock *BB, BasicBlock *IncomingBB) { return llvm::is_contained(predecessors(BB), IncomingBB); } AllSwitchPaths *SwitchPaths; - DominatorTree *DT; + DomTreeUpdater *DTU; AssumptionCache *AC; TargetTransformInfo *TTI; OptimizationRemarkEmitter *ORE; @@ -1399,7 +1425,7 @@ bool DFAJumpThreading::run(Function &F) { << "candidate for jump threading\n"); LLVM_DEBUG(SI->dump()); - unfoldSelectInstrs(DT, Switch.getSelectInsts()); + unfoldSelectInstrs(Switch.getSelectInsts()); if (!Switch.getSelectInsts().empty()) MadeChanges = true; @@ -1421,7 +1447,7 @@ bool DFAJumpThreading::run(Function &F) { } #ifdef NDEBUG - LI->verify(*DT); + LI->verify(DTU->getDomTree()); #endif SmallPtrSet<const Value *, 32> EphValues; @@ -1429,13 +1455,15 @@ bool DFAJumpThreading::run(Function &F) { CodeMetrics::collectEphemeralValues(&F, AC, EphValues); for (AllSwitchPaths SwitchPaths : ThreadableLoops) { - TransformDFA Transform(&SwitchPaths, DT, AC, TTI, ORE, EphValues); + TransformDFA Transform(&SwitchPaths, DTU, AC, TTI, ORE, EphValues); if (Transform.run()) MadeChanges = LoopInfoBroken = true; } + DTU->flush(); + #ifdef EXPENSIVE_CHECKS - assert(DT->verify(DominatorTree::VerificationLevel::Full)); + assert(DTU->getDomTree().verify(DominatorTree::VerificationLevel::Full)); verifyFunction(F, &dbgs()); #endif @@ -1450,7 +1478,9 @@ PreservedAnalyses DFAJumpThreadingPass::run(Function &F, LoopInfo &LI = AM.getResult<LoopAnalysis>(F); TargetTransformInfo &TTI = AM.getResult<TargetIRAnalysis>(F); OptimizationRemarkEmitter ORE(&F); - DFAJumpThreading ThreadImpl(&AC, &DT, &LI, &TTI, &ORE); + + DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy); + DFAJumpThreading ThreadImpl(&AC, &DTU, &LI, &TTI, &ORE); if (!ThreadImpl.run(F)) return PreservedAnalyses::all(); diff --git a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp index 0f8cc6c..2afa7b7 100644 --- a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp +++ b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp @@ -108,7 +108,7 @@ struct SimpleValue { // of instruction handled below (UnaryOperator, etc.). if (CallInst *CI = dyn_cast<CallInst>(Inst)) { if (Function *F = CI->getCalledFunction()) { - switch ((Intrinsic::ID)F->getIntrinsicID()) { + switch (F->getIntrinsicID()) { case Intrinsic::experimental_constrained_fadd: case Intrinsic::experimental_constrained_fsub: case Intrinsic::experimental_constrained_fmul: @@ -154,9 +154,7 @@ struct SimpleValue { } // end anonymous namespace -namespace llvm { - -template <> struct DenseMapInfo<SimpleValue> { +template <> struct llvm::DenseMapInfo<SimpleValue> { static inline SimpleValue getEmptyKey() { return DenseMapInfo<Instruction *>::getEmptyKey(); } @@ -169,8 +167,6 @@ template <> struct DenseMapInfo<SimpleValue> { static bool isEqual(SimpleValue LHS, SimpleValue RHS); }; -} // end namespace llvm - /// Match a 'select' including an optional 'not's of the condition. static bool matchSelectWithOptionalNotCond(Value *V, Value *&Cond, Value *&A, Value *&B, @@ -509,9 +505,7 @@ struct CallValue { } // end anonymous namespace -namespace llvm { - -template <> struct DenseMapInfo<CallValue> { +template <> struct llvm::DenseMapInfo<CallValue> { static inline CallValue getEmptyKey() { return DenseMapInfo<Instruction *>::getEmptyKey(); } @@ -524,8 +518,6 @@ template <> struct DenseMapInfo<CallValue> { static bool isEqual(CallValue LHS, CallValue RHS); }; -} // end namespace llvm - unsigned DenseMapInfo<CallValue>::getHashValue(CallValue Val) { Instruction *Inst = Val.Inst; @@ -580,9 +572,7 @@ struct GEPValue { } // namespace -namespace llvm { - -template <> struct DenseMapInfo<GEPValue> { +template <> struct llvm::DenseMapInfo<GEPValue> { static inline GEPValue getEmptyKey() { return DenseMapInfo<Instruction *>::getEmptyKey(); } @@ -595,8 +585,6 @@ template <> struct DenseMapInfo<GEPValue> { static bool isEqual(const GEPValue &LHS, const GEPValue &RHS); }; -} // end namespace llvm - unsigned DenseMapInfo<GEPValue>::getHashValue(const GEPValue &Val) { auto *GEP = cast<GetElementPtrInst>(Val.Inst); if (Val.ConstantOffset.has_value()) diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index 638952a..3a8ade8 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -170,9 +170,7 @@ struct llvm::GVNPass::Expression { } }; -namespace llvm { - -template <> struct DenseMapInfo<GVNPass::Expression> { +template <> struct llvm::DenseMapInfo<GVNPass::Expression> { static inline GVNPass::Expression getEmptyKey() { return ~0U; } static inline GVNPass::Expression getTombstoneKey() { return ~1U; } @@ -188,8 +186,6 @@ template <> struct DenseMapInfo<GVNPass::Expression> { } }; -} // end namespace llvm - /// Represents a particular available value that we know how to materialize. /// Materialization of an AvailableValue never fails. An AvailableValue is /// implicitly associated with a rematerialization point which is the @@ -2084,13 +2080,6 @@ bool GVNPass::processNonLocalLoad(LoadInst *Load) { return Changed; } -static bool hasUsersIn(Value *V, BasicBlock *BB) { - return any_of(V->users(), [BB](User *U) { - auto *I = dyn_cast<Instruction>(U); - return I && I->getParent() == BB; - }); -} - bool GVNPass::processAssumeIntrinsic(AssumeInst *IntrinsicI) { Value *V = IntrinsicI->getArgOperand(0); @@ -2149,85 +2138,7 @@ bool GVNPass::processAssumeIntrinsic(AssumeInst *IntrinsicI) { } Constant *True = ConstantInt::getTrue(V->getContext()); - bool Changed = false; - - for (BasicBlock *Successor : successors(IntrinsicI->getParent())) { - BasicBlockEdge Edge(IntrinsicI->getParent(), Successor); - - // This property is only true in dominated successors, propagateEquality - // will check dominance for us. - Changed |= propagateEquality(V, True, Edge, false); - } - - // We can replace assume value with true, which covers cases like this: - // call void @llvm.assume(i1 %cmp) - // br i1 %cmp, label %bb1, label %bb2 ; will change %cmp to true - ReplaceOperandsWithMap[V] = True; - - // Similarly, after assume(!NotV) we know that NotV == false. - Value *NotV; - if (match(V, m_Not(m_Value(NotV)))) - ReplaceOperandsWithMap[NotV] = ConstantInt::getFalse(V->getContext()); - - // If we find an equality fact, canonicalize all dominated uses in this block - // to one of the two values. We heuristically choice the "oldest" of the - // two where age is determined by value number. (Note that propagateEquality - // above handles the cross block case.) - // - // Key case to cover are: - // 1) - // %cmp = fcmp oeq float 3.000000e+00, %0 ; const on lhs could happen - // call void @llvm.assume(i1 %cmp) - // ret float %0 ; will change it to ret float 3.000000e+00 - // 2) - // %load = load float, float* %addr - // %cmp = fcmp oeq float %load, %0 - // call void @llvm.assume(i1 %cmp) - // ret float %load ; will change it to ret float %0 - if (auto *CmpI = dyn_cast<CmpInst>(V)) { - if (CmpI->isEquivalence()) { - Value *CmpLHS = CmpI->getOperand(0); - Value *CmpRHS = CmpI->getOperand(1); - // Heuristically pick the better replacement -- the choice of heuristic - // isn't terribly important here, but the fact we canonicalize on some - // replacement is for exposing other simplifications. - // TODO: pull this out as a helper function and reuse w/ existing - // (slightly different) logic. - if (isa<Constant>(CmpLHS) && !isa<Constant>(CmpRHS)) - std::swap(CmpLHS, CmpRHS); - if (!isa<Instruction>(CmpLHS) && isa<Instruction>(CmpRHS)) - std::swap(CmpLHS, CmpRHS); - if ((isa<Argument>(CmpLHS) && isa<Argument>(CmpRHS)) || - (isa<Instruction>(CmpLHS) && isa<Instruction>(CmpRHS))) { - // Move the 'oldest' value to the right-hand side, using the value - // number as a proxy for age. - uint32_t LVN = VN.lookupOrAdd(CmpLHS); - uint32_t RVN = VN.lookupOrAdd(CmpRHS); - if (LVN < RVN) - std::swap(CmpLHS, CmpRHS); - } - - // Handle degenerate case where we either haven't pruned a dead path or a - // removed a trivial assume yet. - if (isa<Constant>(CmpLHS) && isa<Constant>(CmpRHS)) - return Changed; - - LLVM_DEBUG(dbgs() << "Replacing dominated uses of " - << *CmpLHS << " with " - << *CmpRHS << " in block " - << IntrinsicI->getParent()->getName() << "\n"); - - // Setup the replacement map - this handles uses within the same block. - if (hasUsersIn(CmpLHS, IntrinsicI->getParent())) - ReplaceOperandsWithMap[CmpLHS] = CmpRHS; - - // NOTE: The non-block local cases are handled by the call to - // propagateEquality above; this block is just about handling the block - // local cases. TODO: There's a bunch of logic in propagateEqualiy which - // isn't duplicated for the block local case, can we share it somehow? - } - } - return Changed; + return propagateEquality(V, True, IntrinsicI); } static void patchAndReplaceAllUsesWith(Instruction *I, Value *Repl) { @@ -2526,39 +2437,28 @@ void GVNPass::assignBlockRPONumber(Function &F) { InvalidBlockRPONumbers = false; } -bool GVNPass::replaceOperandsForInBlockEquality(Instruction *Instr) const { - bool Changed = false; - for (unsigned OpNum = 0; OpNum < Instr->getNumOperands(); ++OpNum) { - Use &Operand = Instr->getOperandUse(OpNum); - auto It = ReplaceOperandsWithMap.find(Operand.get()); - if (It != ReplaceOperandsWithMap.end()) { - const DataLayout &DL = Instr->getDataLayout(); - if (!canReplacePointersInUseIfEqual(Operand, It->second, DL)) - continue; - - LLVM_DEBUG(dbgs() << "GVN replacing: " << *Operand << " with " - << *It->second << " in instruction " << *Instr << '\n'); - Instr->setOperand(OpNum, It->second); - Changed = true; - } - } - return Changed; -} - -/// The given values are known to be equal in every block +/// The given values are known to be equal in every use /// dominated by 'Root'. Exploit this, for example by replacing 'LHS' with /// 'RHS' everywhere in the scope. Returns whether a change was made. -/// If DominatesByEdge is false, then it means that we will propagate the RHS -/// value starting from the end of Root.Start. -bool GVNPass::propagateEquality(Value *LHS, Value *RHS, - const BasicBlockEdge &Root, - bool DominatesByEdge) { +/// The Root may either be a basic block edge (for conditions) or an +/// instruction (for assumes). +bool GVNPass::propagateEquality( + Value *LHS, Value *RHS, + const std::variant<BasicBlockEdge, Instruction *> &Root) { SmallVector<std::pair<Value*, Value*>, 4> Worklist; Worklist.push_back(std::make_pair(LHS, RHS)); bool Changed = false; - // For speed, compute a conservative fast approximation to - // DT->dominates(Root, Root.getEnd()); - const bool RootDominatesEnd = isOnlyReachableViaThisEdge(Root, DT); + SmallVector<const BasicBlock *> DominatedBlocks; + if (const BasicBlockEdge *Edge = std::get_if<BasicBlockEdge>(&Root)) { + // For speed, compute a conservative fast approximation to + // DT->dominates(Root, Root.getEnd()); + if (isOnlyReachableViaThisEdge(*Edge, DT)) + DominatedBlocks.push_back(Edge->getEnd()); + } else { + Instruction *I = std::get<Instruction *>(Root); + for (const auto *Node : DT->getNode(I->getParent())->children()) + DominatedBlocks.push_back(Node->getBlock()); + } while (!Worklist.empty()) { std::pair<Value*, Value*> Item = Worklist.pop_back_val(); @@ -2606,9 +2506,9 @@ bool GVNPass::propagateEquality(Value *LHS, Value *RHS, // using the leader table is about compiling faster, not optimizing better). // The leader table only tracks basic blocks, not edges. Only add to if we // have the simple case where the edge dominates the end. - if (RootDominatesEnd && !isa<Instruction>(RHS) && - canReplacePointersIfEqual(LHS, RHS, DL)) - LeaderTable.insert(LVN, RHS, Root.getEnd()); + if (!isa<Instruction>(RHS) && canReplacePointersIfEqual(LHS, RHS, DL)) + for (const BasicBlock *BB : DominatedBlocks) + LeaderTable.insert(LVN, RHS, BB); // Replace all occurrences of 'LHS' with 'RHS' everywhere in the scope. As // LHS always has at least one use that is not dominated by Root, this will @@ -2618,12 +2518,14 @@ bool GVNPass::propagateEquality(Value *LHS, Value *RHS, auto CanReplacePointersCallBack = [&DL](const Use &U, const Value *To) { return canReplacePointersInUseIfEqual(U, To, DL); }; - unsigned NumReplacements = - DominatesByEdge - ? replaceDominatedUsesWithIf(LHS, RHS, *DT, Root, - CanReplacePointersCallBack) - : replaceDominatedUsesWithIf(LHS, RHS, *DT, Root.getStart(), - CanReplacePointersCallBack); + unsigned NumReplacements; + if (const BasicBlockEdge *Edge = std::get_if<BasicBlockEdge>(&Root)) + NumReplacements = replaceDominatedUsesWithIf( + LHS, RHS, *DT, *Edge, CanReplacePointersCallBack); + else + NumReplacements = replaceDominatedUsesWithIf( + LHS, RHS, *DT, std::get<Instruction *>(Root), + CanReplacePointersCallBack); if (NumReplacements > 0) { Changed = true; @@ -2682,26 +2584,45 @@ bool GVNPass::propagateEquality(Value *LHS, Value *RHS, // If the number we were assigned was brand new then there is no point in // looking for an instruction realizing it: there cannot be one! if (Num < NextNum) { - Value *NotCmp = findLeader(Root.getEnd(), Num); - if (NotCmp && isa<Instruction>(NotCmp)) { - unsigned NumReplacements = - DominatesByEdge - ? replaceDominatedUsesWith(NotCmp, NotVal, *DT, Root) - : replaceDominatedUsesWith(NotCmp, NotVal, *DT, - Root.getStart()); - Changed |= NumReplacements > 0; - NumGVNEqProp += NumReplacements; - // Cached information for anything that uses NotCmp will be invalid. - if (MD) - MD->invalidateCachedPointerInfo(NotCmp); + for (const auto &Entry : LeaderTable.getLeaders(Num)) { + // Only look at leaders that either dominate the start of the edge, + // or are dominated by the end. This check is not necessary for + // correctness, it only discards cases for which the following + // use replacement will not work anyway. + if (const BasicBlockEdge *Edge = std::get_if<BasicBlockEdge>(&Root)) { + if (!DT->dominates(Entry.BB, Edge->getStart()) && + !DT->dominates(Edge->getEnd(), Entry.BB)) + continue; + } else { + auto *InstBB = std::get<Instruction *>(Root)->getParent(); + if (!DT->dominates(Entry.BB, InstBB) && + !DT->dominates(InstBB, Entry.BB)) + continue; + } + + Value *NotCmp = Entry.Val; + if (NotCmp && isa<Instruction>(NotCmp)) { + unsigned NumReplacements; + if (const BasicBlockEdge *Edge = std::get_if<BasicBlockEdge>(&Root)) + NumReplacements = + replaceDominatedUsesWith(NotCmp, NotVal, *DT, *Edge); + else + NumReplacements = replaceDominatedUsesWith( + NotCmp, NotVal, *DT, std::get<Instruction *>(Root)); + Changed |= NumReplacements > 0; + NumGVNEqProp += NumReplacements; + // Cached information for anything that uses NotCmp will be invalid. + if (MD) + MD->invalidateCachedPointerInfo(NotCmp); + } } } // Ensure that any instruction in scope that gets the "A < B" value number // is replaced with false. // The leader table only tracks basic blocks, not edges. Only add to if we // have the simple case where the edge dominates the end. - if (RootDominatesEnd) - LeaderTable.insert(Num, NotVal, Root.getEnd()); + for (const BasicBlock *BB : DominatedBlocks) + LeaderTable.insert(Num, NotVal, BB); continue; } @@ -2789,11 +2710,11 @@ bool GVNPass::processInstruction(Instruction *I) { Value *TrueVal = ConstantInt::getTrue(TrueSucc->getContext()); BasicBlockEdge TrueE(Parent, TrueSucc); - Changed |= propagateEquality(BranchCond, TrueVal, TrueE, true); + Changed |= propagateEquality(BranchCond, TrueVal, TrueE); Value *FalseVal = ConstantInt::getFalse(FalseSucc->getContext()); BasicBlockEdge FalseE(Parent, FalseSucc); - Changed |= propagateEquality(BranchCond, FalseVal, FalseE, true); + Changed |= propagateEquality(BranchCond, FalseVal, FalseE); return Changed; } @@ -2814,7 +2735,7 @@ bool GVNPass::processInstruction(Instruction *I) { // If there is only a single edge, propagate the case value into it. if (SwitchEdges.lookup(Dst) == 1) { BasicBlockEdge E(Parent, Dst); - Changed |= propagateEquality(SwitchCond, Case.getCaseValue(), E, true); + Changed |= propagateEquality(SwitchCond, Case.getCaseValue(), E); } } return Changed; @@ -2942,8 +2863,6 @@ bool GVNPass::processBlock(BasicBlock *BB) { if (DeadBlocks.count(BB)) return false; - // Clearing map before every BB because it can be used only for single BB. - ReplaceOperandsWithMap.clear(); bool ChangedFunction = false; // Since we may not have visited the input blocks of the phis, we can't @@ -2955,11 +2874,8 @@ bool GVNPass::processBlock(BasicBlock *BB) { for (PHINode *PN : PHINodesToRemove) { removeInstruction(PN); } - for (Instruction &Inst : make_early_inc_range(*BB)) { - if (!ReplaceOperandsWithMap.empty()) - ChangedFunction |= replaceOperandsForInBlockEquality(&Inst); + for (Instruction &Inst : make_early_inc_range(*BB)) ChangedFunction |= processInstruction(&Inst); - } return ChangedFunction; } diff --git a/llvm/lib/Transforms/Scalar/NewGVN.cpp b/llvm/lib/Transforms/Scalar/NewGVN.cpp index 3c1a8ba..80aa98d 100644 --- a/llvm/lib/Transforms/Scalar/NewGVN.cpp +++ b/llvm/lib/Transforms/Scalar/NewGVN.cpp @@ -434,10 +434,6 @@ private: int StoreCount = 0; }; -} // end anonymous namespace - -namespace llvm { - struct ExactEqualsExpression { const Expression &E; @@ -449,8 +445,9 @@ struct ExactEqualsExpression { return E.exactlyEquals(Other); } }; +} // end anonymous namespace -template <> struct DenseMapInfo<const Expression *> { +template <> struct llvm::DenseMapInfo<const Expression *> { static const Expression *getEmptyKey() { auto Val = static_cast<uintptr_t>(-1); Val <<= PointerLikeTypeTraits<const Expression *>::NumLowBitsAvailable; @@ -493,8 +490,6 @@ template <> struct DenseMapInfo<const Expression *> { } }; -} // end namespace llvm - namespace { class NewGVN { diff --git a/llvm/lib/Transforms/Utils/CanonicalizeFreezeInLoops.cpp b/llvm/lib/Transforms/Utils/CanonicalizeFreezeInLoops.cpp index 2190dcd..a87822c 100644 --- a/llvm/lib/Transforms/Utils/CanonicalizeFreezeInLoops.cpp +++ b/llvm/lib/Transforms/Utils/CanonicalizeFreezeInLoops.cpp @@ -84,10 +84,6 @@ public: bool run(); }; -} // anonymous namespace - -namespace llvm { - struct FrozenIndPHIInfo { // A freeze instruction that uses an induction phi FreezeInst *FI = nullptr; @@ -103,7 +99,9 @@ struct FrozenIndPHIInfo { bool operator==(const FrozenIndPHIInfo &Other) { return FI == Other.FI; } }; -template <> struct DenseMapInfo<FrozenIndPHIInfo> { +} // namespace + +template <> struct llvm::DenseMapInfo<FrozenIndPHIInfo> { static inline FrozenIndPHIInfo getEmptyKey() { return FrozenIndPHIInfo(DenseMapInfo<PHINode *>::getEmptyKey(), DenseMapInfo<BinaryOperator *>::getEmptyKey()); @@ -124,8 +122,6 @@ template <> struct DenseMapInfo<FrozenIndPHIInfo> { }; }; -} // end namespace llvm - // Given U = (value, user), replace value with freeze(value), and let // SCEV forget user. The inserted freeze is placed in the preheader. void CanonicalizeFreezeInLoopsImpl::InsertFreezeAndForgetFromSCEV(Use &U) { diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp index b6ca52e..46f2903 100644 --- a/llvm/lib/Transforms/Utils/Local.cpp +++ b/llvm/lib/Transforms/Utils/Local.cpp @@ -3246,6 +3246,13 @@ unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To, return ::replaceDominatedUsesWith(From, To, Dominates); } +unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To, + DominatorTree &DT, + const Instruction *I) { + auto Dominates = [&](const Use &U) { return DT.dominates(I, U); }; + return ::replaceDominatedUsesWith(From, To, Dominates); +} + unsigned llvm::replaceDominatedUsesWithIf( Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Root, function_ref<bool(const Use &U, const Value *To)> ShouldReplace) { @@ -3264,6 +3271,15 @@ unsigned llvm::replaceDominatedUsesWithIf( return ::replaceDominatedUsesWith(From, To, DominatesAndShouldReplace); } +unsigned llvm::replaceDominatedUsesWithIf( + Value *From, Value *To, DominatorTree &DT, const Instruction *I, + function_ref<bool(const Use &U, const Value *To)> ShouldReplace) { + auto DominatesAndShouldReplace = [&](const Use &U) { + return DT.dominates(I, U) && ShouldReplace(U, To); + }; + return ::replaceDominatedUsesWith(From, To, DominatesAndShouldReplace); +} + bool llvm::callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI) { // Check if the function is specifically marked as a gc leaf function. diff --git a/llvm/lib/Transforms/Utils/LowerInvoke.cpp b/llvm/lib/Transforms/Utils/LowerInvoke.cpp index ff2ab3c..cecb662 100644 --- a/llvm/lib/Transforms/Utils/LowerInvoke.cpp +++ b/llvm/lib/Transforms/Utils/LowerInvoke.cpp @@ -27,15 +27,15 @@ using namespace llvm; STATISTIC(NumInvokes, "Number of invokes replaced"); namespace { - class LowerInvokeLegacyPass : public FunctionPass { - public: - static char ID; // Pass identification, replacement for typeid - explicit LowerInvokeLegacyPass() : FunctionPass(ID) { - initializeLowerInvokeLegacyPassPass(*PassRegistry::getPassRegistry()); - } - bool runOnFunction(Function &F) override; - }; -} +class LowerInvokeLegacyPass : public FunctionPass { +public: + static char ID; // Pass identification, replacement for typeid + explicit LowerInvokeLegacyPass() : FunctionPass(ID) { + initializeLowerInvokeLegacyPassPass(*PassRegistry::getPassRegistry()); + } + bool runOnFunction(Function &F) override; +}; +} // namespace char LowerInvokeLegacyPass::ID = 0; INITIALIZE_PASS(LowerInvokeLegacyPass, "lowerinvoke", @@ -78,11 +78,12 @@ bool LowerInvokeLegacyPass::runOnFunction(Function &F) { return runImpl(F); } -namespace llvm { -char &LowerInvokePassID = LowerInvokeLegacyPass::ID; +char &llvm::LowerInvokePassID = LowerInvokeLegacyPass::ID; // Public Interface To the LowerInvoke pass. -FunctionPass *createLowerInvokePass() { return new LowerInvokeLegacyPass(); } +FunctionPass *llvm::createLowerInvokePass() { + return new LowerInvokeLegacyPass(); +} PreservedAnalyses LowerInvokePass::run(Function &F, FunctionAnalysisManager &AM) { @@ -92,4 +93,3 @@ PreservedAnalyses LowerInvokePass::run(Function &F, return PreservedAnalyses::none(); } -} diff --git a/llvm/lib/Transforms/Utils/MisExpect.cpp b/llvm/lib/Transforms/Utils/MisExpect.cpp index ca7e09d..1585e9e 100644 --- a/llvm/lib/Transforms/Utils/MisExpect.cpp +++ b/llvm/lib/Transforms/Utils/MisExpect.cpp @@ -48,8 +48,6 @@ using namespace llvm; using namespace misexpect; -namespace llvm { - // Command line option to enable/disable the warning when profile data suggests // a mismatch with the use of the llvm.expect intrinsic static cl::opt<bool> PGOWarnMisExpect( @@ -63,22 +61,18 @@ static cl::opt<uint32_t> MisExpectTolerance( cl::desc("Prevents emitting diagnostics when profile counts are " "within N% of the threshold..")); -} // namespace llvm - -namespace { - -bool isMisExpectDiagEnabled(LLVMContext &Ctx) { +static bool isMisExpectDiagEnabled(const LLVMContext &Ctx) { return PGOWarnMisExpect || Ctx.getMisExpectWarningRequested(); } -uint32_t getMisExpectTolerance(LLVMContext &Ctx) { +static uint32_t getMisExpectTolerance(const LLVMContext &Ctx) { return std::max(static_cast<uint32_t>(MisExpectTolerance), Ctx.getDiagnosticsMisExpectTolerance()); } -Instruction *getInstCondition(Instruction *I) { +static const Instruction *getInstCondition(const Instruction *I) { assert(I != nullptr && "MisExpect target Instruction cannot be nullptr"); - Instruction *Ret = nullptr; + const Instruction *Ret = nullptr; if (auto *B = dyn_cast<BranchInst>(I)) { Ret = dyn_cast<Instruction>(B->getCondition()); } @@ -97,8 +91,8 @@ Instruction *getInstCondition(Instruction *I) { return Ret ? Ret : I; } -void emitMisexpectDiagnostic(Instruction *I, LLVMContext &Ctx, - uint64_t ProfCount, uint64_t TotalCount) { +static void emitMisexpectDiagnostic(const Instruction *I, LLVMContext &Ctx, + uint64_t ProfCount, uint64_t TotalCount) { double PercentageCorrect = (double)ProfCount / TotalCount; auto PerString = formatv("{0:P} ({1} / {2})", PercentageCorrect, ProfCount, TotalCount); @@ -106,20 +100,16 @@ void emitMisexpectDiagnostic(Instruction *I, LLVMContext &Ctx, "Potential performance regression from use of the llvm.expect intrinsic: " "Annotation was correct on {0} of profiled executions.", PerString); - Instruction *Cond = getInstCondition(I); + const Instruction *Cond = getInstCondition(I); if (isMisExpectDiagEnabled(Ctx)) Ctx.diagnose(DiagnosticInfoMisExpect(Cond, Twine(PerString))); OptimizationRemarkEmitter ORE(I->getParent()->getParent()); ORE.emit(OptimizationRemark(DEBUG_TYPE, "misexpect", Cond) << RemStr.str()); } -} // namespace - -namespace llvm { -namespace misexpect { - -void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, - ArrayRef<uint32_t> ExpectedWeights) { +void misexpect::verifyMisExpect(const Instruction &I, + ArrayRef<uint32_t> RealWeights, + ArrayRef<uint32_t> ExpectedWeights) { // To determine if we emit a diagnostic, we need to compare the branch weights // from the profile to those added by the llvm.expect intrinsic. // So first, we extract the "likely" and "unlikely" weights from @@ -128,15 +118,13 @@ void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, uint64_t LikelyBranchWeight = 0, UnlikelyBranchWeight = std::numeric_limits<uint32_t>::max(); size_t MaxIndex = 0; - for (size_t Idx = 0, End = ExpectedWeights.size(); Idx < End; Idx++) { - uint32_t V = ExpectedWeights[Idx]; + for (const auto &[Idx, V] : enumerate(ExpectedWeights)) { if (LikelyBranchWeight < V) { LikelyBranchWeight = V; MaxIndex = Idx; } - if (UnlikelyBranchWeight > V) { + if (UnlikelyBranchWeight > V) UnlikelyBranchWeight = V; - } } const uint64_t ProfiledWeight = RealWeights[MaxIndex]; @@ -161,7 +149,7 @@ void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, uint64_t ScaledThreshold = LikelyProbablilty.scale(RealWeightsTotal); // clamp tolerance range to [0, 100) - auto Tolerance = getMisExpectTolerance(I.getContext()); + uint32_t Tolerance = getMisExpectTolerance(I.getContext()); Tolerance = std::clamp(Tolerance, 0u, 99u); // Allow users to relax checking by N% i.e., if they use a 5% tolerance, @@ -175,8 +163,8 @@ void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, RealWeightsTotal); } -void checkBackendInstrumentation(Instruction &I, - const ArrayRef<uint32_t> RealWeights) { +void misexpect::checkBackendInstrumentation(const Instruction &I, + ArrayRef<uint32_t> RealWeights) { // Backend checking assumes any existing weight comes from an `llvm.expect` // intrinsic. However, SampleProfiling + ThinLTO add branch weights multiple // times, leading to an invalid assumption in our checking. Backend checks @@ -190,24 +178,19 @@ void checkBackendInstrumentation(Instruction &I, verifyMisExpect(I, RealWeights, ExpectedWeights); } -void checkFrontendInstrumentation(Instruction &I, - const ArrayRef<uint32_t> ExpectedWeights) { +void misexpect::checkFrontendInstrumentation( + const Instruction &I, ArrayRef<uint32_t> ExpectedWeights) { SmallVector<uint32_t> RealWeights; if (!extractBranchWeights(I, RealWeights)) return; verifyMisExpect(I, RealWeights, ExpectedWeights); } -void checkExpectAnnotations(Instruction &I, - const ArrayRef<uint32_t> ExistingWeights, - bool IsFrontend) { - if (IsFrontend) { +void misexpect::checkExpectAnnotations(const Instruction &I, + ArrayRef<uint32_t> ExistingWeights, + bool IsFrontend) { + if (IsFrontend) checkFrontendInstrumentation(I, ExistingWeights); - } else { + else checkBackendInstrumentation(I, ExistingWeights); - } } - -} // namespace misexpect -} // namespace llvm -#undef DEBUG_TYPE diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp index 9ac3be1..d831c27 100644 --- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp @@ -7740,8 +7740,7 @@ struct SwitchSuccWrapper { DenseMap<PHINode *, SmallDenseMap<BasicBlock *, Value *, 8>> *PhiPredIVs; }; -namespace llvm { -template <> struct DenseMapInfo<const SwitchSuccWrapper *> { +template <> struct llvm::DenseMapInfo<const SwitchSuccWrapper *> { static const SwitchSuccWrapper *getEmptyKey() { return static_cast<SwitchSuccWrapper *>( DenseMapInfo<void *>::getEmptyKey()); @@ -7809,7 +7808,6 @@ template <> struct DenseMapInfo<const SwitchSuccWrapper *> { return true; } }; -} // namespace llvm bool SimplifyCFGOpt::simplifyDuplicateSwitchArms(SwitchInst *SI, DomTreeUpdater *DTU) { diff --git a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll index e67cae7d..8cd29e6 100644 --- a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll +++ b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll @@ -20,7 +20,7 @@ define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp { ; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %i.011, ptr %arrayidx8, align 8 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: %0 = load i64, ptr %arrayidx17, align 8 -; CHECK-NEXT: da analyze - flow [-3 -2]! +; CHECK-NEXT: da analyze - flow [-3 -2] / assuming 1 loop level(s) fused: [-3 -2 -1]! ; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx17, align 8 --> Dst: %0 = load i64, ptr %arrayidx17, align 8 diff --git a/llvm/test/Analysis/DependenceAnalysis/SameSDLoops.ll b/llvm/test/Analysis/DependenceAnalysis/SameSDLoops.ll index f80e2cf..57962e0 100644 --- a/llvm/test/Analysis/DependenceAnalysis/SameSDLoops.ll +++ b/llvm/test/Analysis/DependenceAnalysis/SameSDLoops.ll @@ -18,7 +18,7 @@ define void @samebd0(ptr %A) nounwind uwtable ssp { ; CHECK-NEXT: Src: store i64 %i.013, ptr %arrayidx12, align 8 --> Dst: store i64 %i.013, ptr %arrayidx12, align 8 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i64 %i.013, ptr %arrayidx12, align 8 --> Dst: store i64 %l17.04, ptr %arrayidx24, align 8 -; CHECK-NEXT: da analyze - output [-4 -3]! / assuming 2 loop level(s) fused: [-4 -3 -3 -1]! +; CHECK-NEXT: da analyze - output [-4 -3] / assuming 2 loop level(s) fused: [-4 -3 -3 -1]! ; CHECK-NEXT: Src: store i64 %l17.04, ptr %arrayidx24, align 8 --> Dst: store i64 %l17.04, ptr %arrayidx24, align 8 ; CHECK-NEXT: da analyze - none! ; @@ -96,7 +96,7 @@ define void @samebd1(ptr %A) nounwind uwtable ssp { ; CHECK-NEXT: Src: store i64 %i.03, ptr %arrayidx, align 4 --> Dst: store i64 %i.03, ptr %arrayidx, align 4 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i64 %i.03, ptr %arrayidx, align 4 --> Dst: %0 = load i64, ptr %arrayidx7, align 4 -; CHECK-NEXT: da analyze - flow [|<]! / assuming 1 loop level(s) fused: [<=|<]! +; CHECK-NEXT: da analyze - flow [|<] / assuming 1 loop level(s) fused: [<=|<]! ; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 4 --> Dst: %0 = load i64, ptr %arrayidx7, align 4 ; CHECK-NEXT: da analyze - none! ; @@ -148,7 +148,7 @@ define void @non_samebd0(ptr %A) nounwind uwtable ssp { ; CHECK-NEXT: Src: store i64 %i.013, ptr %arrayidx12, align 8 --> Dst: store i64 %i.013, ptr %arrayidx12, align 8 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i64 %i.013, ptr %arrayidx12, align 8 --> Dst: store i64 %l17.04, ptr %arrayidx24, align 8 -; CHECK-NEXT: da analyze - output [-4 -3]!{{$}} +; CHECK-NEXT: da analyze - output [-4 -3]! ; CHECK-NEXT: Src: store i64 %l17.04, ptr %arrayidx24, align 8 --> Dst: store i64 %l17.04, ptr %arrayidx24, align 8 ; CHECK-NEXT: da analyze - none! ; @@ -227,7 +227,7 @@ define void @non_samebd1(ptr %A) nounwind uwtable ssp { ; CHECK-NEXT: Src: store i64 %i.03, ptr %arrayidx, align 4 --> Dst: store i64 %i.03, ptr %arrayidx, align 4 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i64 %i.03, ptr %arrayidx, align 4 --> Dst: %0 = load i64, ptr %arrayidx7, align 4 -; CHECK-NEXT: da analyze - flow [|<]!{{$}} +; CHECK-NEXT: da analyze - flow [|<]! ; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 4 --> Dst: %0 = load i64, ptr %arrayidx7, align 4 ; CHECK-NEXT: da analyze - none! ; diff --git a/llvm/test/Assembler/dicompileunit-conflicting-language-fields.ll b/llvm/test/Assembler/dicompileunit-conflicting-language-fields.ll new file mode 100644 index 0000000..3aad27b --- /dev/null +++ b/llvm/test/Assembler/dicompileunit-conflicting-language-fields.ll @@ -0,0 +1,4 @@ +; RUN: not llvm-as < %s -disable-output 2>&1 | FileCheck %s + +; CHECK: <stdin>:[[@LINE+1]]:15: error: can only specify one of 'language' and 'sourceLanguageName' on !DICompileUnit +!0 = distinct !DICompileUnit(language: DW_LANG_C, sourceLanguageName: DW_LNAME_C, file: !DIFile(filename: "a", directory: "b")) diff --git a/llvm/test/Assembler/dicompileunit-invalid-language.ll b/llvm/test/Assembler/dicompileunit-invalid-language.ll new file mode 100644 index 0000000..da93c4f --- /dev/null +++ b/llvm/test/Assembler/dicompileunit-invalid-language.ll @@ -0,0 +1,22 @@ +; RUN: split-file %s %t +; RUN: not llvm-as < %t/invalid_dw_lang.ll -disable-output 2>&1 | FileCheck %s --check-prefix=INVALID_DW_LANG +; RUN: not llvm-as < %t/invalid_dw_lang_2.ll -disable-output 2>&1 | FileCheck %s --check-prefix=INVALID_DW_LANG_2 +; RUN: not llvm-as < %t/invalid_dw_lname.ll -disable-output 2>&1 | FileCheck %s --check-prefix=INVALID_DW_LNAME +; RUN: not llvm-as < %t/invalid_dw_lname_2.ll -disable-output 2>&1 | FileCheck %s --check-prefix=INVALID_DW_LNAME_2 + +; INVALID_DW_LANG: invalid DWARF language 'DW_LANG_blah' +; INVALID_DW_LANG_2: expected DWARF language +; INVALID_DW_LNAME: invalid DWARF source language name 'DW_LNAME_blah' +; INVALID_DW_LNAME_2: expected DWARF source language name + +;--- invalid_dw_lang.ll +!0 = distinct !DICompileUnit(language: DW_LANG_blah) + +;--- invalid_dw_lang_2.ll +!0 = distinct !DICompileUnit(language: DW_LNAME_C) + +;--- invalid_dw_lname.ll +!0 = distinct !DICompileUnit(sourceLanguageName: DW_LNAME_blah) + +;--- invalid_dw_lname_2.ll +!0 = distinct !DICompileUnit(sourceLanguageName: DW_LANG_C) diff --git a/llvm/test/Assembler/invalid-dicompileunit-missing-language.ll b/llvm/test/Assembler/invalid-dicompileunit-missing-language.ll index 8e4cb02..ebc86e3 100644 --- a/llvm/test/Assembler/invalid-dicompileunit-missing-language.ll +++ b/llvm/test/Assembler/invalid-dicompileunit-missing-language.ll @@ -1,4 +1,4 @@ ; RUN: not llvm-as < %s -disable-output 2>&1 | FileCheck %s -; CHECK: <stdin>:[[@LINE+1]]:74: error: missing required field 'language' +; CHECK: <stdin>:[[@LINE+1]]:15: error: missing one of 'language' or 'sourceLanguageName', required for !DICompileUnit !0 = distinct !DICompileUnit(file: !DIFile(filename: "a", directory: "b")) diff --git a/llvm/test/Bitcode/dwarf-source-language-name.ll b/llvm/test/Bitcode/dwarf-source-language-name.ll new file mode 100644 index 0000000..e989363 --- /dev/null +++ b/llvm/test/Bitcode/dwarf-source-language-name.ll @@ -0,0 +1,15 @@ +; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s + +; CHECK: sourceLanguageName: DW_LNAME_ObjC_plus_plus + +source_filename = "cu.cpp" +target triple = "arm64-apple-macosx" + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!3, !4} + +!0 = distinct !DICompileUnit(sourceLanguageName: DW_LNAME_ObjC_plus_plus, file: !1, producer: "handwritten", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !2, splitDebugInlining: false, nameTableKind: Apple, sysroot: "/") +!1 = !DIFile(filename: "cu.cpp", directory: "/tmp") +!2 = !{} +!3 = !{i32 7, !"Dwarf Version", i32 5} +!4 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/knownbits-smulh.mir b/llvm/test/CodeGen/AArch64/GlobalISel/knownbits-smulh.mir new file mode 100644 index 0000000..b9cde95 --- /dev/null +++ b/llvm/test/CodeGen/AArch64/GlobalISel/knownbits-smulh.mir @@ -0,0 +1,137 @@ +# NOTE: Assertions have been autogenerated by utils/update_givaluetracking_test_checks.py UTC_ARGS: --version 6 +# RUN: llc -mtriple=aarch64 -passes='print<gisel-value-tracking>' -filetype=null %s 2>&1 | FileCheck %s + +--- +name: Cst +body: | + bb.0: + ; CHECK-LABEL: name: @Cst + ; CHECK-NEXT: %0:_ KnownBits:00010011 SignBits:3 + ; CHECK-NEXT: %1:_ KnownBits:11100000 SignBits:3 + ; CHECK-NEXT: %2:_ KnownBits:11111101 SignBits:6 + %0:_(s8) = G_CONSTANT i8 19 + %1:_(s8) = G_CONSTANT i8 224 + %2:_(s8) = G_SMULH %0, %1 +... +--- +name: CstZero +body: | + bb.0: + ; CHECK-LABEL: name: @CstZero + ; CHECK-NEXT: %0:_ KnownBits:11111111 SignBits:8 + ; CHECK-NEXT: %1:_ KnownBits:00000000 SignBits:8 + ; CHECK-NEXT: %2:_ KnownBits:00000000 SignBits:8 + %0:_(s8) = G_CONSTANT i8 255 + %1:_(s8) = G_CONSTANT i8 0 + %2:_(s8) = G_SMULH %0, %1 +... +--- +name: ScalarVar +body: | + bb.0: + ; CHECK-LABEL: name: @ScalarVar + ; CHECK-NEXT: %0:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %1:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %2:_ KnownBits:???????? SignBits:1 + %0:_(s8) = COPY $b0 + %1:_(s8) = COPY $b1 + %2:_(s8) = G_SMULH %0, %1 +... +--- +name: ScalarZero +body: | + bb.0: + ; CHECK-LABEL: name: @ScalarZero + ; CHECK-NEXT: %0:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %1:_ KnownBits:00000000 SignBits:8 + ; CHECK-NEXT: %2:_ KnownBits:00000000 SignBits:8 + %0:_(s8) = COPY $b0 + %1:_(s8) = G_CONSTANT i8 0 + %2:_(s8) = G_SMULH %0, %1 +... +--- +name: ScalarVarAbs +body: | + bb.0: + ; CHECK-LABEL: name: @ScalarVarAbs + ; CHECK-NEXT: %0:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %1:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %2:_ KnownBits:???????????????? SignBits:9 + ; CHECK-NEXT: %3:_ KnownBits:0000000000000001 SignBits:15 + ; CHECK-NEXT: %4:_ KnownBits:???????????????? SignBits:1 + %0:_(s8) = COPY $b0 + %1:_(s8) = G_ABS %0 + %2:_(s16) = G_SEXT %1 + %3:_(s16) = G_CONSTANT i16 1 + %4:_(s16) = G_SMULH %2, %3 +... +--- +name: SplatVecCst +body: | + bb.0: + ; CHECK-LABEL: name: @SplatVecCst + ; CHECK-NEXT: %0:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %1:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %2:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %3:_ KnownBits:00000000 SignBits:8 + %0:_(s8) = G_CONSTANT i8 250 + %1:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %0(s8) + %2:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %0(s8) + %3:_(<vscale x 16 x s8>) = G_SMULH %1, %2 +... +--- +name: SplatVecPartScalar +body: | + bb.0: + ; CHECK-LABEL: name: @SplatVecPartScalar + ; CHECK-NEXT: %0:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %1:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %2:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %3:_ KnownBits:00001111 SignBits:4 + ; CHECK-NEXT: %4:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %5:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %6:_ KnownBits:???????? SignBits:1 + %0:_(s8) = G_CONSTANT i8 250 + %1:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %0(s8) + %2:_(s8) = G_IMPLICIT_DEF + %3:_(s8) = G_CONSTANT i8 15 + %4:_(s8) = G_AND %2, %3 + %5:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %4(s8) + %6:_(<vscale x 16 x s8>) = G_SMULH %1, %5 +... +--- +name: VecCst +body: | + bb.0: + ; CHECK-LABEL: name: @VecCst + ; CHECK-NEXT: %0:_ KnownBits:00011001 SignBits:3 + ; CHECK-NEXT: %1:_ KnownBits:11100001 SignBits:3 + ; CHECK-NEXT: %2:_ KnownBits:?????001 SignBits:3 + ; CHECK-NEXT: %3:_ KnownBits:?????001 SignBits:3 + ; CHECK-NEXT: %4:_ KnownBits:???????? SignBits:1 + %0:_(s8) = G_CONSTANT i8 25 + %1:_(s8) = G_CONSTANT i8 225 + %2:_(<2 x s8>) = G_BUILD_VECTOR %0:_(s8), %1:_(s8) + %3:_(<2 x s8>) = G_BUILD_VECTOR %0:_(s8), %1:_(s8) + %4:_(<2 x s8>) = G_SMULH %2, %3 +... +--- +name: VecPartScalar +body: | + bb.0: + ; CHECK-LABEL: name: @VecPartScalar + ; CHECK-NEXT: %0:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %1:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %2:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %3:_ KnownBits:00001111 SignBits:4 + ; CHECK-NEXT: %4:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %5:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %6:_ KnownBits:???????? SignBits:1 + %0:_(s8) = G_CONSTANT i8 250 + %1:_(<2 x s8>) = G_BUILD_VECTOR %0:_(s8), %0:_(s8) + %2:_(s8) = G_IMPLICIT_DEF + %3:_(s8) = G_CONSTANT i8 15 + %4:_(s8) = G_AND %2, %3 + %5:_(<2 x s8>) = G_BUILD_VECTOR %4:_(s8), %4:_(s8) + %6:_(<2 x s8>) = G_SMULH %1, %5 +... diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/knownbits-umulh.mir b/llvm/test/CodeGen/AArch64/GlobalISel/knownbits-umulh.mir new file mode 100644 index 0000000..debdbaa --- /dev/null +++ b/llvm/test/CodeGen/AArch64/GlobalISel/knownbits-umulh.mir @@ -0,0 +1,137 @@ +# NOTE: Assertions have been autogenerated by utils/update_givaluetracking_test_checks.py UTC_ARGS: --version 6 +# RUN: llc -mtriple=aarch64 -passes='print<gisel-value-tracking>' -filetype=null %s 2>&1 | FileCheck %s + +--- +name: Cst +body: | + bb.0: + ; CHECK-LABEL: name: @Cst + ; CHECK-NEXT: %0:_ KnownBits:00010011 SignBits:3 + ; CHECK-NEXT: %1:_ KnownBits:11100000 SignBits:3 + ; CHECK-NEXT: %2:_ KnownBits:00010000 SignBits:3 + %0:_(s8) = G_CONSTANT i8 19 + %1:_(s8) = G_CONSTANT i8 224 + %2:_(s8) = G_UMULH %0, %1 +... +--- +name: CstZero +body: | + bb.0: + ; CHECK-LABEL: name: @CstZero + ; CHECK-NEXT: %0:_ KnownBits:11111111 SignBits:8 + ; CHECK-NEXT: %1:_ KnownBits:00000000 SignBits:8 + ; CHECK-NEXT: %2:_ KnownBits:00000000 SignBits:8 + %0:_(s8) = G_CONSTANT i8 255 + %1:_(s8) = G_CONSTANT i8 0 + %2:_(s8) = G_UMULH %0, %1 +... +--- +name: ScalarVar +body: | + bb.0: + ; CHECK-LABEL: name: @ScalarVar + ; CHECK-NEXT: %0:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %1:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %2:_ KnownBits:???????? SignBits:1 + %0:_(s8) = COPY $b0 + %1:_(s8) = COPY $b1 + %2:_(s8) = G_UMULH %0, %1 +... +--- +name: ScalarZero +body: | + bb.0: + ; CHECK-LABEL: name: @ScalarZero + ; CHECK-NEXT: %0:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %1:_ KnownBits:00000000 SignBits:8 + ; CHECK-NEXT: %2:_ KnownBits:00000000 SignBits:8 + %0:_(s8) = COPY $b0 + %1:_(s8) = G_CONSTANT i8 0 + %2:_(s8) = G_UMULH %0, %1 +... +--- +name: ScalarVarAbs +body: | + bb.0: + ; CHECK-LABEL: name: @ScalarVarAbs + ; CHECK-NEXT: %0:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %1:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %2:_ KnownBits:???????????????? SignBits:9 + ; CHECK-NEXT: %3:_ KnownBits:0000000000000001 SignBits:15 + ; CHECK-NEXT: %4:_ KnownBits:0000000000000000 SignBits:16 + %0:_(s8) = COPY $b0 + %1:_(s8) = G_ABS %0 + %2:_(s16) = G_SEXT %1 + %3:_(s16) = G_CONSTANT i16 1 + %4:_(s16) = G_UMULH %2, %3 +... +--- +name: SplatVecCst +body: | + bb.0: + ; CHECK-LABEL: name: @SplatVecCst + ; CHECK-NEXT: %0:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %1:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %2:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %3:_ KnownBits:11110100 SignBits:4 + %0:_(s8) = G_CONSTANT i8 250 + %1:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %0(s8) + %2:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %0(s8) + %3:_(<vscale x 16 x s8>) = G_UMULH %1, %2 +... +--- +name: SplatVecPartScalar +body: | + bb.0: + ; CHECK-LABEL: name: @SplatVecPartScalar + ; CHECK-NEXT: %0:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %1:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %2:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %3:_ KnownBits:00001111 SignBits:4 + ; CHECK-NEXT: %4:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %5:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %6:_ KnownBits:0000???? SignBits:4 + %0:_(s8) = G_CONSTANT i8 250 + %1:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %0(s8) + %2:_(s8) = G_IMPLICIT_DEF + %3:_(s8) = G_CONSTANT i8 15 + %4:_(s8) = G_AND %2, %3 + %5:_(<vscale x 16 x s8>) = G_SPLAT_VECTOR %4(s8) + %6:_(<vscale x 16 x s8>) = G_UMULH %1, %5 +... +--- +name: VecCst +body: | + bb.0: + ; CHECK-LABEL: name: @VecCst + ; CHECK-NEXT: %0:_ KnownBits:00011001 SignBits:3 + ; CHECK-NEXT: %1:_ KnownBits:11100001 SignBits:3 + ; CHECK-NEXT: %2:_ KnownBits:?????001 SignBits:3 + ; CHECK-NEXT: %3:_ KnownBits:?????001 SignBits:3 + ; CHECK-NEXT: %4:_ KnownBits:???????? SignBits:1 + %0:_(s8) = G_CONSTANT i8 25 + %1:_(s8) = G_CONSTANT i8 225 + %2:_(<2 x s8>) = G_BUILD_VECTOR %0:_(s8), %1:_(s8) + %3:_(<2 x s8>) = G_BUILD_VECTOR %0:_(s8), %1:_(s8) + %4:_(<2 x s8>) = G_UMULH %2, %3 +... +--- +name: VecPartScalar +body: | + bb.0: + ; CHECK-LABEL: name: @VecPartScalar + ; CHECK-NEXT: %0:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %1:_ KnownBits:11111010 SignBits:5 + ; CHECK-NEXT: %2:_ KnownBits:???????? SignBits:1 + ; CHECK-NEXT: %3:_ KnownBits:00001111 SignBits:4 + ; CHECK-NEXT: %4:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %5:_ KnownBits:0000???? SignBits:4 + ; CHECK-NEXT: %6:_ KnownBits:0000???? SignBits:4 + %0:_(s8) = G_CONSTANT i8 250 + %1:_(<2 x s8>) = G_BUILD_VECTOR %0:_(s8), %0:_(s8) + %2:_(s8) = G_IMPLICIT_DEF + %3:_(s8) = G_CONSTANT i8 15 + %4:_(s8) = G_AND %2, %3 + %5:_(<2 x s8>) = G_BUILD_VECTOR %4:_(s8), %4:_(s8) + %6:_(<2 x s8>) = G_UMULH %1, %5 +... diff --git a/llvm/test/CodeGen/AArch64/arm64-indexed-memory.ll b/llvm/test/CodeGen/AArch64/arm64-indexed-memory.ll index 322a96a..e8e5631 100644 --- a/llvm/test/CodeGen/AArch64/arm64-indexed-memory.ll +++ b/llvm/test/CodeGen/AArch64/arm64-indexed-memory.ll @@ -739,14 +739,12 @@ define ptr @postidx32_shalf(ptr %src, ptr %out, half %a) { ; ; GISEL-LABEL: postidx32_shalf: ; GISEL: ; %bb.0: -; GISEL-NEXT: movi d1, #0000000000000000 -; GISEL-NEXT: ldr h2, [x0], #4 +; GISEL-NEXT: ldr h1, [x0], #4 ; GISEL-NEXT: ; kill: def $h0 killed $h0 def $s0 ; GISEL-NEXT: fmov w9, s0 -; GISEL-NEXT: fcvt s3, h2 -; GISEL-NEXT: fmov w8, s2 -; GISEL-NEXT: fcvt s1, h1 -; GISEL-NEXT: fcmp s3, s1 +; GISEL-NEXT: fcvt s2, h1 +; GISEL-NEXT: fmov w8, s1 +; GISEL-NEXT: fcmp s2, #0.0 ; GISEL-NEXT: csel w8, w8, w9, mi ; GISEL-NEXT: strh w8, [x1] ; GISEL-NEXT: ret diff --git a/llvm/test/CodeGen/AArch64/f16-instructions.ll b/llvm/test/CodeGen/AArch64/f16-instructions.ll index b234ef7..085170c 100644 --- a/llvm/test/CodeGen/AArch64/f16-instructions.ll +++ b/llvm/test/CodeGen/AArch64/f16-instructions.ll @@ -782,18 +782,16 @@ define void @test_fccmp(half %in, ptr %out) { ; ; CHECK-CVT-GI-LABEL: test_fccmp: ; CHECK-CVT-GI: // %bb.0: -; CHECK-CVT-GI-NEXT: adrp x8, .LCPI29_0 ; CHECK-CVT-GI-NEXT: // kill: def $h0 killed $h0 def $s0 -; CHECK-CVT-GI-NEXT: fcvt s2, h0 -; CHECK-CVT-GI-NEXT: ldr h1, [x8, :lo12:.LCPI29_0] -; CHECK-CVT-GI-NEXT: adrp x8, .LCPI29_1 -; CHECK-CVT-GI-NEXT: ldr h4, [x8, :lo12:.LCPI29_1] +; CHECK-CVT-GI-NEXT: fcvt s1, h0 +; CHECK-CVT-GI-NEXT: fmov s2, #5.00000000 +; CHECK-CVT-GI-NEXT: adrp x8, .LCPI29_0 +; CHECK-CVT-GI-NEXT: fmov s3, #8.00000000 +; CHECK-CVT-GI-NEXT: fcmp s1, s2 +; CHECK-CVT-GI-NEXT: ldr h2, [x8, :lo12:.LCPI29_0] ; CHECK-CVT-GI-NEXT: fmov w8, s0 -; CHECK-CVT-GI-NEXT: fcvt s3, h1 -; CHECK-CVT-GI-NEXT: fmov w9, s1 -; CHECK-CVT-GI-NEXT: fcvt s4, h4 -; CHECK-CVT-GI-NEXT: fcmp s2, s3 -; CHECK-CVT-GI-NEXT: fccmp s2, s4, #4, mi +; CHECK-CVT-GI-NEXT: fmov w9, s2 +; CHECK-CVT-GI-NEXT: fccmp s1, s3, #4, mi ; CHECK-CVT-GI-NEXT: csel w8, w8, w9, gt ; CHECK-CVT-GI-NEXT: strh w8, [x0] ; CHECK-CVT-GI-NEXT: ret diff --git a/llvm/test/CodeGen/AArch64/fcvt-fixed.ll b/llvm/test/CodeGen/AArch64/fcvt-fixed.ll index 7409bfb..743d160 100644 --- a/llvm/test/CodeGen/AArch64/fcvt-fixed.ll +++ b/llvm/test/CodeGen/AArch64/fcvt-fixed.ll @@ -149,33 +149,21 @@ define i64 @fcvtzs_f64_i64_64(double %dbl) { } define i32 @fcvtzs_f16_i32_7(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzs_f16_i32_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_f16_i32_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_f16_i32_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs w0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_f16_i32_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI8_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI8_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_f16_i32_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI8_0 @@ -189,33 +177,21 @@ define i32 @fcvtzs_f16_i32_7(half %flt) { } define i32 @fcvtzs_f16_i32_15(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzs_f16_i32_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_f16_i32_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_f16_i32_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs w0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_f16_i32_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI9_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI9_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_f16_i32_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI9_0 @@ -229,33 +205,21 @@ define i32 @fcvtzs_f16_i32_15(half %flt) { } define i64 @fcvtzs_f16_i64_7(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzs_f16_i64_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_f16_i64_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_f16_i64_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs x0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_f16_i64_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI10_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI10_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_f16_i64_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI10_0 @@ -269,33 +233,21 @@ define i64 @fcvtzs_f16_i64_7(half %flt) { } define i64 @fcvtzs_f16_i64_15(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzs_f16_i64_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_f16_i64_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_f16_i64_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs x0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_f16_i64_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI11_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI11_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_f16_i64_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI11_0 @@ -453,33 +405,21 @@ define i64 @fcvtzu_f64_i64_64(double %dbl) { } define i32 @fcvtzu_f16_i32_7(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzu_f16_i32_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_f16_i32_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_f16_i32_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu w0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_f16_i32_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI20_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI20_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_f16_i32_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI20_0 @@ -493,33 +433,21 @@ define i32 @fcvtzu_f16_i32_7(half %flt) { } define i32 @fcvtzu_f16_i32_15(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzu_f16_i32_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_f16_i32_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_f16_i32_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu w0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_f16_i32_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI21_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI21_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_f16_i32_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI21_0 @@ -533,33 +461,21 @@ define i32 @fcvtzu_f16_i32_15(half %flt) { } define i64 @fcvtzu_f16_i64_7(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzu_f16_i64_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_f16_i64_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_f16_i64_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu x0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_f16_i64_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI22_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI22_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_f16_i64_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI22_0 @@ -573,33 +489,21 @@ define i64 @fcvtzu_f16_i64_7(half %flt) { } define i64 @fcvtzu_f16_i64_15(half %flt) { -; CHECK-SD-NO16-LABEL: fcvtzu_f16_i64_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_f16_i64_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_f16_i64_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu x0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_f16_i64_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI23_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI23_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_f16_i64_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI23_0 @@ -774,13 +678,11 @@ define half @scvtf_f16_i32_7(i32 %int) { ; ; CHECK-GI-NO16-LABEL: scvtf_f16_i32_7: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: scvtf s0, w0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI32_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI32_0] +; CHECK-GI-NO16-NEXT: scvtf s1, w0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #67, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -814,13 +716,11 @@ define half @scvtf_f16_i32_15(i32 %int) { ; ; CHECK-GI-NO16-LABEL: scvtf_f16_i32_15: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: scvtf s0, w0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI33_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI33_0] +; CHECK-GI-NO16-NEXT: scvtf s1, w0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #71, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -854,13 +754,11 @@ define half @scvtf_f16_i64_7(i64 %long) { ; ; CHECK-GI-NO16-LABEL: scvtf_f16_i64_7: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: scvtf s0, x0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI34_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI34_0] +; CHECK-GI-NO16-NEXT: scvtf s1, x0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #67, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -894,13 +792,11 @@ define half @scvtf_f16_i64_15(i64 %long) { ; ; CHECK-GI-NO16-LABEL: scvtf_f16_i64_15: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: scvtf s0, x0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI35_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI35_0] +; CHECK-GI-NO16-NEXT: scvtf s1, x0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #71, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -1078,13 +974,11 @@ define half @ucvtf_f16_i32_7(i32 %int) { ; ; CHECK-GI-NO16-LABEL: ucvtf_f16_i32_7: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: ucvtf s0, w0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI44_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI44_0] +; CHECK-GI-NO16-NEXT: ucvtf s1, w0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #67, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -1118,13 +1012,11 @@ define half @ucvtf_f16_i32_15(i32 %int) { ; ; CHECK-GI-NO16-LABEL: ucvtf_f16_i32_15: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: ucvtf s0, w0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI45_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI45_0] +; CHECK-GI-NO16-NEXT: ucvtf s1, w0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #71, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -1158,13 +1050,11 @@ define half @ucvtf_f16_i64_7(i64 %long) { ; ; CHECK-GI-NO16-LABEL: ucvtf_f16_i64_7: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: ucvtf s0, x0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI46_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI46_0] +; CHECK-GI-NO16-NEXT: ucvtf s1, x0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #67, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -1198,13 +1088,11 @@ define half @ucvtf_f16_i64_15(i64 %long) { ; ; CHECK-GI-NO16-LABEL: ucvtf_f16_i64_15: ; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: ucvtf s0, x0 -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI47_0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI47_0] +; CHECK-GI-NO16-NEXT: ucvtf s1, x0 +; CHECK-GI-NO16-NEXT: movi v0.2s, #71, lsl #24 +; CHECK-GI-NO16-NEXT: fcvt h1, s1 ; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fdiv s0, s0, s1 +; CHECK-GI-NO16-NEXT: fdiv s0, s1, s0 ; CHECK-GI-NO16-NEXT: fcvt h0, s0 ; CHECK-GI-NO16-NEXT: ret ; @@ -1356,33 +1244,21 @@ define i64 @fcvtzs_sat_f64_i64_64(double %dbl) { } define i32 @fcvtzs_sat_f16_i32_7(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzs_sat_f16_i32_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_sat_f16_i32_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_sat_f16_i32_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs w0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_sat_f16_i32_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI55_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI55_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_sat_f16_i32_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI55_0 @@ -1396,33 +1272,21 @@ define i32 @fcvtzs_sat_f16_i32_7(half %dbl) { } define i32 @fcvtzs_sat_f16_i32_15(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzs_sat_f16_i32_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_sat_f16_i32_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_sat_f16_i32_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs w0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_sat_f16_i32_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI56_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI56_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_sat_f16_i32_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI56_0 @@ -1436,33 +1300,21 @@ define i32 @fcvtzs_sat_f16_i32_15(half %dbl) { } define i64 @fcvtzs_sat_f16_i64_7(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzs_sat_f16_i64_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_sat_f16_i64_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_sat_f16_i64_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs x0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_sat_f16_i64_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI57_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI57_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_sat_f16_i64_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI57_0 @@ -1476,33 +1328,21 @@ define i64 @fcvtzs_sat_f16_i64_7(half %dbl) { } define i64 @fcvtzs_sat_f16_i64_15(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzs_sat_f16_i64_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzs x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzs_sat_f16_i64_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzs x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzs_sat_f16_i64_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzs x0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzs_sat_f16_i64_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI58_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI58_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzs x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzs_sat_f16_i64_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI58_0 @@ -1650,33 +1490,21 @@ define i64 @fcvtzu_sat_f64_i64_64(double %dbl) { } define i32 @fcvtzu_sat_f16_i32_7(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzu_sat_f16_i32_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_sat_f16_i32_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_sat_f16_i32_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu w0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_sat_f16_i32_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI66_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI66_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_sat_f16_i32_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI66_0 @@ -1690,33 +1518,21 @@ define i32 @fcvtzu_sat_f16_i32_7(half %dbl) { } define i32 @fcvtzu_sat_f16_i32_15(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzu_sat_f16_i32_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu w0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_sat_f16_i32_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu w0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_sat_f16_i32_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu w0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_sat_f16_i32_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI67_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI67_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu w0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_sat_f16_i32_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI67_0 @@ -1730,33 +1546,21 @@ define i32 @fcvtzu_sat_f16_i32_15(half %dbl) { } define i64 @fcvtzu_sat_f16_i64_7(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzu_sat_f16_i64_7: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #67, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_sat_f16_i64_7: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #67, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_sat_f16_i64_7: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu x0, h0, #7 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_sat_f16_i64_7: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI68_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI68_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_sat_f16_i64_7: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI68_0 @@ -1770,33 +1574,21 @@ define i64 @fcvtzu_sat_f16_i64_7(half %dbl) { } define i64 @fcvtzu_sat_f16_i64_15(half %dbl) { -; CHECK-SD-NO16-LABEL: fcvtzu_sat_f16_i64_15: -; CHECK-SD-NO16: // %bb.0: -; CHECK-SD-NO16-NEXT: movi v1.2s, #71, lsl #24 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fmul s0, s0, s1 -; CHECK-SD-NO16-NEXT: fcvt h0, s0 -; CHECK-SD-NO16-NEXT: fcvt s0, h0 -; CHECK-SD-NO16-NEXT: fcvtzu x0, s0 -; CHECK-SD-NO16-NEXT: ret +; CHECK-NO16-LABEL: fcvtzu_sat_f16_i64_15: +; CHECK-NO16: // %bb.0: +; CHECK-NO16-NEXT: movi v1.2s, #71, lsl #24 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fmul s0, s0, s1 +; CHECK-NO16-NEXT: fcvt h0, s0 +; CHECK-NO16-NEXT: fcvt s0, h0 +; CHECK-NO16-NEXT: fcvtzu x0, s0 +; CHECK-NO16-NEXT: ret ; ; CHECK-SD-FP16-LABEL: fcvtzu_sat_f16_i64_15: ; CHECK-SD-FP16: // %bb.0: ; CHECK-SD-FP16-NEXT: fcvtzu x0, h0, #15 ; CHECK-SD-FP16-NEXT: ret ; -; CHECK-GI-NO16-LABEL: fcvtzu_sat_f16_i64_15: -; CHECK-GI-NO16: // %bb.0: -; CHECK-GI-NO16-NEXT: adrp x8, .LCPI69_0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: ldr h1, [x8, :lo12:.LCPI69_0] -; CHECK-GI-NO16-NEXT: fcvt s1, h1 -; CHECK-GI-NO16-NEXT: fmul s0, s0, s1 -; CHECK-GI-NO16-NEXT: fcvt h0, s0 -; CHECK-GI-NO16-NEXT: fcvt s0, h0 -; CHECK-GI-NO16-NEXT: fcvtzu x0, s0 -; CHECK-GI-NO16-NEXT: ret -; ; CHECK-GI-FP16-LABEL: fcvtzu_sat_f16_i64_15: ; CHECK-GI-FP16: // %bb.0: ; CHECK-GI-FP16-NEXT: adrp x8, .LCPI69_0 @@ -1811,4 +1603,3 @@ define i64 @fcvtzu_sat_f16_i64_15(half %dbl) { ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ; CHECK: {{.*}} ; CHECK-FP16: {{.*}} -; CHECK-NO16: {{.*}} diff --git a/llvm/test/CodeGen/AArch64/frem-power2.ll b/llvm/test/CodeGen/AArch64/frem-power2.ll index 98276b6..e1bc742 100644 --- a/llvm/test/CodeGen/AArch64/frem-power2.ll +++ b/llvm/test/CodeGen/AArch64/frem-power2.ll @@ -100,9 +100,8 @@ define half @hrem2_nsz(half %x) { ; CHECK-GI-NEXT: str x30, [sp, #-16]! // 8-byte Folded Spill ; CHECK-GI-NEXT: .cfi_def_cfa_offset 16 ; CHECK-GI-NEXT: .cfi_offset w30, -16 -; CHECK-GI-NEXT: fmov h1, #2.00000000 ; CHECK-GI-NEXT: fcvt s0, h0 -; CHECK-GI-NEXT: fcvt s1, h1 +; CHECK-GI-NEXT: fmov s1, #2.00000000 ; CHECK-GI-NEXT: bl fmodf ; CHECK-GI-NEXT: fcvt h0, s0 ; CHECK-GI-NEXT: ldr x30, [sp], #16 // 8-byte Folded Reload diff --git a/llvm/test/CodeGen/AArch64/pr58431.ll b/llvm/test/CodeGen/AArch64/pr58431.ll index 467ceb0..a373004 100644 --- a/llvm/test/CodeGen/AArch64/pr58431.ll +++ b/llvm/test/CodeGen/AArch64/pr58431.ll @@ -9,7 +9,7 @@ define i32 @f(i64 %0) { ; CHECK-NEXT: mov w10, #10 // =0xa ; CHECK-NEXT: eor x8, x8, #0x8000000000000003 ; CHECK-NEXT: umulh x8, x9, x8 -; CHECK-NEXT: msub x0, x8, x10, x9 +; CHECK-NEXT: umsubl x0, w8, w10, x9 ; CHECK-NEXT: // kill: def $w0 killed $w0 killed $x0 ; CHECK-NEXT: ret %2 = trunc i64 %0 to i32 diff --git a/llvm/test/CodeGen/AArch64/sve-asrd.ll b/llvm/test/CodeGen/AArch64/sve-asrd.ll new file mode 100644 index 0000000..66db1a5 --- /dev/null +++ b/llvm/test/CodeGen/AArch64/sve-asrd.ll @@ -0,0 +1,53 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6 +; RUN: llc -mattr=+sve -combiner-disabled < %s | FileCheck %s + +target triple = "aarch64-unknown-linux-gnu" + +; Ensure we don't try to represent sdiv-by-one using ARSD. +define <16 x i16> @sdiv_by_one_v16i16(<16 x i16> %a) vscale_range(2,2) { +; CHECK-LABEL: sdiv_by_one_v16i16: +; CHECK: // %bb.0: +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: adrp x8, .LCPI0_0 +; CHECK-NEXT: add x8, x8, :lo12:.LCPI0_0 +; CHECK-NEXT: // kill: def $q1 killed $q1 def $z1 +; CHECK-NEXT: // kill: def $q0 killed $q0 def $z0 +; CHECK-NEXT: ld1h { z2.h }, p0/z, [x8] +; CHECK-NEXT: sunpklo z0.s, z0.h +; CHECK-NEXT: sunpklo z1.s, z1.h +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: sunpklo z3.s, z2.h +; CHECK-NEXT: ext z2.b, z2.b, z2.b, #16 +; CHECK-NEXT: sunpklo z2.s, z2.h +; CHECK-NEXT: sdiv z0.s, p0/m, z0.s, z3.s +; CHECK-NEXT: sdiv z1.s, p0/m, z1.s, z2.s +; CHECK-NEXT: ptrue p0.h, vl8 +; CHECK-NEXT: uzp1 z0.h, z0.h, z0.h +; CHECK-NEXT: uzp1 z1.h, z1.h, z1.h +; CHECK-NEXT: splice z0.h, p0, z0.h, z1.h +; CHECK-NEXT: movprfx z1, z0 +; CHECK-NEXT: ext z1.b, z1.b, z0.b, #16 +; CHECK-NEXT: // kill: def $q0 killed $q0 killed $z0 +; CHECK-NEXT: // kill: def $q1 killed $q1 killed $z1 +; CHECK-NEXT: ret + %res = sdiv <16 x i16> %a, splat(i16 1) + ret <16 x i16> %res +} + +; Ensure we don't try to represent sdiv-by-one using ARSD. +define <vscale x 8 x i16> @sdiv_by_one_nxv8i16(<vscale x 8 x i16> %a) { +; CHECK-LABEL: sdiv_by_one_nxv8i16: +; CHECK: // %bb.0: +; CHECK-NEXT: mov z1.h, #1 // =0x1 +; CHECK-NEXT: sunpkhi z2.s, z0.h +; CHECK-NEXT: sunpklo z0.s, z0.h +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: sunpkhi z3.s, z1.h +; CHECK-NEXT: sunpklo z1.s, z1.h +; CHECK-NEXT: sdiv z2.s, p0/m, z2.s, z3.s +; CHECK-NEXT: sdiv z0.s, p0/m, z0.s, z1.s +; CHECK-NEXT: uzp1 z0.h, z0.h, z2.h +; CHECK-NEXT: ret + %res = sdiv <vscale x 8 x i16> %a, splat(i16 1) + ret <vscale x 8 x i16> %res +} diff --git a/llvm/test/CodeGen/AArch64/sve-vector-deinterleave.ll b/llvm/test/CodeGen/AArch64/sve-vector-deinterleave.ll index 139ecaf..67197b3fe 100644 --- a/llvm/test/CodeGen/AArch64/sve-vector-deinterleave.ll +++ b/llvm/test/CodeGen/AArch64/sve-vector-deinterleave.ll @@ -231,6 +231,274 @@ define {<vscale x 2 x i64>, <vscale x 2 x i64>} @vector_deinterleave_nxv2i64_nxv ret {<vscale x 2 x i64>, <vscale x 2 x i64>} %retval } +define {<vscale x 2 x half>, <vscale x 2 x half>, <vscale x 2 x half>} @vector_deinterleave_nxv2f16_nxv6f16(<vscale x 6 x half> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv2f16_nxv6f16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: uunpkhi z1.s, z0.h +; CHECK-NEXT: uunpklo z0.s, z0.h +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: uunpklo z1.d, z1.s +; CHECK-NEXT: uunpkhi z2.d, z0.s +; CHECK-NEXT: uunpklo z0.d, z0.s +; CHECK-NEXT: str z1, [sp, #2, mul vl] +; CHECK-NEXT: str z2, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3d { z0.d - z2.d }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 2 x half>, <vscale x 2 x half>, <vscale x 2 x half>} @llvm.vector.deinterleave3.nxv6f16(<vscale x 6 x half> %vec) + ret {<vscale x 2 x half>, <vscale x 2 x half>, <vscale x 2 x half>} %retval +} + +define {<vscale x 4 x half>, <vscale x 4 x half>, <vscale x 4 x half>} @vector_deinterleave_nxv4f16_nxv12f16(<vscale x 12 x half> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv4f16_nxv12f16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: uunpklo z1.s, z1.h +; CHECK-NEXT: uunpkhi z2.s, z0.h +; CHECK-NEXT: uunpklo z0.s, z0.h +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: str z1, [sp, #2, mul vl] +; CHECK-NEXT: str z2, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3w { z0.s - z2.s }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 4 x half>, <vscale x 4 x half>, <vscale x 4 x half>} @llvm.vector.deinterleave3.nxv12f16(<vscale x 12 x half> %vec) + ret {<vscale x 4 x half>, <vscale x 4 x half>, <vscale x 4 x half>} %retval +} + +define {<vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>} @vector_deinterleave_nxv8f16_nxv24f16(<vscale x 24 x half> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv8f16_nxv24f16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3h { z0.h - z2.h }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>} @llvm.vector.deinterleave3.nxv24f16(<vscale x 24 x half> %vec) + ret {<vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>} %retval +} + +define {<vscale x 2 x float>, <vscale x 2 x float>, <vscale x 2 x float>} @vector_deinterleave_nxv2f32_nxv6f32(<vscale x 6 x float> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv2f32_nxv6f32: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: uunpklo z1.d, z1.s +; CHECK-NEXT: uunpkhi z2.d, z0.s +; CHECK-NEXT: uunpklo z0.d, z0.s +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: str z1, [sp, #2, mul vl] +; CHECK-NEXT: str z2, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3d { z0.d - z2.d }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 2 x float>, <vscale x 2 x float>, <vscale x 2 x float>} @llvm.vector.deinterleave3.nxv6f32(<vscale x 6 x float> %vec) + ret {<vscale x 2 x float>, <vscale x 2 x float>, <vscale x 2 x float>} %retval +} + +define {<vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>} @vector_deinterleave_nxv4f32_nxv12f32(<vscale x 12 x float> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv4f32_nxv12f32: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3w { z0.s - z2.s }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>} @llvm.vector.deinterleave3.nxv12f32(<vscale x 12 x float> %vec) + ret {<vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>} %retval +} + +define {<vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>} @vector_deinterleave_nxv2f64_nxv6f64(<vscale x 6 x double> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv2f64_nxv6f64: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3d { z0.d - z2.d }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>} @llvm.vector.deinterleave3.nxv6f64(<vscale x 6 x double> %vec) + ret {<vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>} %retval +} + +define {<vscale x 2 x bfloat>, <vscale x 2 x bfloat>, <vscale x 2 x bfloat>} @vector_deinterleave_nxv2bf16_nxv6bf16(<vscale x 6 x bfloat> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv2bf16_nxv6bf16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: uunpkhi z1.s, z0.h +; CHECK-NEXT: uunpklo z0.s, z0.h +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: uunpklo z1.d, z1.s +; CHECK-NEXT: uunpkhi z2.d, z0.s +; CHECK-NEXT: uunpklo z0.d, z0.s +; CHECK-NEXT: str z1, [sp, #2, mul vl] +; CHECK-NEXT: str z2, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3d { z0.d - z2.d }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 2 x bfloat>, <vscale x 2 x bfloat>, <vscale x 2 x bfloat>} @llvm.vector.deinterleave3.nxv6bf16(<vscale x 6 x bfloat> %vec) + ret {<vscale x 2 x bfloat>, <vscale x 2 x bfloat>, <vscale x 2 x bfloat>} %retval +} + +define {<vscale x 4 x bfloat>, <vscale x 4 x bfloat>, <vscale x 4 x bfloat>} @vector_deinterleave_nxv4bf16_nxv12bf16(<vscale x 12 x bfloat> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv4bf16_nxv12bf16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: uunpklo z1.s, z1.h +; CHECK-NEXT: uunpkhi z2.s, z0.h +; CHECK-NEXT: uunpklo z0.s, z0.h +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: str z1, [sp, #2, mul vl] +; CHECK-NEXT: str z2, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3w { z0.s - z2.s }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 4 x bfloat>, <vscale x 4 x bfloat>, <vscale x 4 x bfloat>} @llvm.vector.deinterleave3.nxv12bf16(<vscale x 12 x bfloat> %vec) + ret {<vscale x 4 x bfloat>, <vscale x 4 x bfloat>, <vscale x 4 x bfloat>} %retval +} + +define {<vscale x 8 x bfloat>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>} @vector_deinterleave_nxv8bf16_nxv24bf16(<vscale x 24 x bfloat> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv8bf16_nxv24bf16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3h { z0.h - z2.h }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 8 x bfloat>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>} @llvm.vector.deinterleave3.nxv24bf16(<vscale x 24 x bfloat> %vec) + ret {<vscale x 8 x bfloat>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>} %retval +} + +; Integers + +define {<vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>} @vector_deinterleave_nxv16i8_nxv48i8(<vscale x 48 x i8> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv16i8_nxv48i8: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.b +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3b { z0.b - z2.b }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>} @llvm.vector.deinterleave3.nxv48i8(<vscale x 48 x i8> %vec) + ret {<vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>} %retval +} + +define {<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>} @vector_deinterleave_nxv8i16_nxv24i16(<vscale x 24 x i16> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv8i16_nxv24i16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3h { z0.h - z2.h }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>} @llvm.vector.deinterleave3.nxv24i16(<vscale x 24 x i16> %vec) + ret {<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>} %retval +} + +define {<vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>} @vector_deinterleave_nxv4i32_nxvv12i32(<vscale x 12 x i32> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv4i32_nxvv12i32: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3w { z0.s - z2.s }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>} @llvm.vector.deinterleave3.nxv12i32(<vscale x 12 x i32> %vec) + ret {<vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>} %retval +} + +define {<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>} @vector_deinterleave_nxv2i64_nxv6i64(<vscale x 6 x i64> %vec) { +; CHECK-LABEL: vector_deinterleave_nxv2i64_nxv6i64: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: str z2, [sp, #2, mul vl] +; CHECK-NEXT: str z1, [sp, #1, mul vl] +; CHECK-NEXT: str z0, [sp] +; CHECK-NEXT: ld3d { z0.d - z2.d }, p0/z, [sp] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call {<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>} @llvm.vector.deinterleave3.nxv6i64(<vscale x 6 x i64> %vec) + ret {<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>} %retval +} + define {<vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>} @vector_deinterleave_nxv16i8_nxv64i8(<vscale x 64 x i8> %vec) { ; SVE-LABEL: vector_deinterleave_nxv16i8_nxv64i8: ; SVE: // %bb.0: @@ -599,31 +867,3 @@ define {<vscale x 2 x i32>, <vscale x 2 x i32>} @vector_deinterleave_nxv2i32_nxv %retval = call {<vscale x 2 x i32>,<vscale x 2 x i32>} @llvm.vector.deinterleave2.nxv4i32(<vscale x 4 x i32> %vec) ret {<vscale x 2 x i32>, <vscale x 2 x i32>} %retval } - -; Floating declarations -declare {<vscale x 2 x half>,<vscale x 2 x half>} @llvm.vector.deinterleave2.nxv4f16(<vscale x 4 x half>) -declare {<vscale x 4 x half>, <vscale x 4 x half>} @llvm.vector.deinterleave2.nxv8f16(<vscale x 8 x half>) -declare {<vscale x 2 x float>, <vscale x 2 x float>} @llvm.vector.deinterleave2.nxv4f32(<vscale x 4 x float>) -declare {<vscale x 8 x half>, <vscale x 8 x half>} @llvm.vector.deinterleave2.nxv16f16(<vscale x 16 x half>) -declare {<vscale x 4 x float>, <vscale x 4 x float>} @llvm.vector.deinterleave2.nxv8f32(<vscale x 8 x float>) -declare {<vscale x 2 x double>, <vscale x 2 x double>} @llvm.vector.deinterleave2.nxv4f64(<vscale x 4 x double>) - -; Integer declarations -declare {<vscale x 16 x i8>, <vscale x 16 x i8>} @llvm.vector.deinterleave2.nxv32i8(<vscale x 32 x i8>) -declare {<vscale x 8 x i16>, <vscale x 8 x i16>} @llvm.vector.deinterleave2.nxv16i16(<vscale x 16 x i16>) -declare {<vscale x 4 x i32>, <vscale x 4 x i32>} @llvm.vector.deinterleave2.nxv8i32(<vscale x 8 x i32>) -declare {<vscale x 2 x i64>, <vscale x 2 x i64>} @llvm.vector.deinterleave2.nxv4i64(<vscale x 4 x i64>) - -; Predicated declarations -declare {<vscale x 16 x i1>, <vscale x 16 x i1>} @llvm.vector.deinterleave2.nxv32i1(<vscale x 32 x i1>) -declare {<vscale x 8 x i1>, <vscale x 8 x i1>} @llvm.vector.deinterleave2.nxv16i1(<vscale x 16 x i1>) -declare {<vscale x 4 x i1>, <vscale x 4 x i1>} @llvm.vector.deinterleave2.nxv8i1(<vscale x 8 x i1>) -declare {<vscale x 2 x i1>, <vscale x 2 x i1>} @llvm.vector.deinterleave2.nxv4i1(<vscale x 4 x i1>) - -; Illegal size type -declare {<vscale x 4 x i64>, <vscale x 4 x i64>} @llvm.vector.deinterleave2.nxv8i64(<vscale x 8 x i64>) -declare {<vscale x 8 x i64>, <vscale x 8 x i64>} @llvm.vector.deinterleave2.nxv16i64(<vscale x 16 x i64>) - -declare {<vscale x 8 x i8>, <vscale x 8 x i8>} @llvm.vector.deinterleave2.nxv16i8(<vscale x 16 x i8>) -declare {<vscale x 4 x i16>, <vscale x 4 x i16>} @llvm.vector.deinterleave2.nxv8i16(<vscale x 8 x i16>) -declare {<vscale x 2 x i32>, <vscale x 2 x i32>} @llvm.vector.deinterleave2.nxv4i32(<vscale x 4 x i32>) diff --git a/llvm/test/CodeGen/AArch64/sve-vector-interleave.ll b/llvm/test/CodeGen/AArch64/sve-vector-interleave.ll index c7fb2db..49f185c 100644 --- a/llvm/test/CodeGen/AArch64/sve-vector-interleave.ll +++ b/llvm/test/CodeGen/AArch64/sve-vector-interleave.ll @@ -221,6 +221,318 @@ define <vscale x 4 x i64> @interleave2_nxv4i64(<vscale x 2 x i64> %vec0, <vscale ret <vscale x 4 x i64> %retval } +define <vscale x 6 x half> @interleave3_nxv6f16(<vscale x 2 x half> %vec0, <vscale x 2 x half> %vec1, <vscale x 2 x half> %vec2) { +; CHECK-LABEL: interleave3_nxv6f16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3d { z0.d - z2.d }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp, #2, mul vl] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp] +; CHECK-NEXT: uzp1 z0.s, z0.s, z0.s +; CHECK-NEXT: uzp1 z1.s, z2.s, z1.s +; CHECK-NEXT: uzp1 z0.h, z1.h, z0.h +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 6 x half> @llvm.vector.interleave3.nxv6f16(<vscale x 2 x half> %vec0, <vscale x 2 x half> %vec1, <vscale x 2 x half> %vec2) + ret <vscale x 6 x half> %retval +} + +define <vscale x 12 x half> @interleave3_nxv12f16(<vscale x 4 x half> %vec0, <vscale x 4 x half> %vec1, <vscale x 4 x half> %vec2) { +; CHECK-LABEL: interleave3_nxv12f16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-5 +; CHECK-NEXT: .cfi_escape 0x0f, 0x09, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x11, 0x28, 0x1e, 0x22 // sp + 16 + 40 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: addpl x8, sp, #4 +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3w { z0.s - z2.s }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp, #1, mul vl] +; CHECK-NEXT: ldr z1, [sp] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: uzp1 z0.h, z1.h, z0.h +; CHECK-NEXT: st1h { z2.s }, p0, [x8, #7, mul vl] +; CHECK-NEXT: str z0, [sp, #3, mul vl] +; CHECK-NEXT: ldr z1, [sp, #4, mul vl] +; CHECK-NEXT: ldr z0, [sp, #3, mul vl] +; CHECK-NEXT: addvl sp, sp, #5 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 12 x half> @llvm.vector.interleave3.nxv12f16(<vscale x 4 x half> %vec0, <vscale x 4 x half> %vec1, <vscale x 4 x half> %vec2) + ret <vscale x 12 x half> %retval +} + +define <vscale x 24 x half> @interleave3_nxv24f16(<vscale x 8 x half> %vec0, <vscale x 8 x half> %vec1, <vscale x 8 x half> %vec2) { +; CHECK-LABEL: interleave3_nxv24f16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3h { z0.h - z2.h }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 24 x half> @llvm.vector.interleave3.nxv24f16(<vscale x 8 x half> %vec0, <vscale x 8 x half> %vec1, <vscale x 8 x half> %vec2) + ret <vscale x 24 x half> %retval +} + +define <vscale x 6 x float> @interleave3_nxv6f32(<vscale x 2 x float> %vec0, <vscale x 2 x float> %vec1, <vscale x 2 x float> %vec2) { +; CHECK-LABEL: interleave3_nxv6f32: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-5 +; CHECK-NEXT: .cfi_escape 0x0f, 0x09, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x11, 0x28, 0x1e, 0x22 // sp + 16 + 40 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: addpl x8, sp, #4 +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3d { z0.d - z2.d }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp, #1, mul vl] +; CHECK-NEXT: ldr z1, [sp] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: uzp1 z0.s, z1.s, z0.s +; CHECK-NEXT: st1w { z2.d }, p0, [x8, #7, mul vl] +; CHECK-NEXT: str z0, [sp, #3, mul vl] +; CHECK-NEXT: ldr z1, [sp, #4, mul vl] +; CHECK-NEXT: ldr z0, [sp, #3, mul vl] +; CHECK-NEXT: addvl sp, sp, #5 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 6 x float> @llvm.vector.interleave3.nxv6f32(<vscale x 2 x float> %vec0, <vscale x 2 x float> %vec1, <vscale x 2 x float> %vec2) + ret <vscale x 6 x float> %retval +} + +define <vscale x 12 x float> @interleave3_nxv12f32(<vscale x 4 x float> %vec0, <vscale x 4 x float> %vec1, <vscale x 4 x float> %vec2) { +; CHECK-LABEL: interleave3_nxv12f32: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3w { z0.s - z2.s }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 12 x float> @llvm.vector.interleave3.nxv12f32(<vscale x 4 x float> %vec0, <vscale x 4 x float> %vec1, <vscale x 4 x float> %vec2) + ret <vscale x 12 x float> %retval +} + +define <vscale x 6 x double> @interleave3_nxv6f64(<vscale x 2 x double> %vec0, <vscale x 2 x double> %vec1, <vscale x 2 x double> %vec2) { +; CHECK-LABEL: interleave3_nxv6f64: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3d { z0.d - z2.d }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 6 x double>@llvm.vector.interleave3.nxv6f64(<vscale x 2 x double> %vec0, <vscale x 2 x double> %vec1, <vscale x 2 x double> %vec2) + ret <vscale x 6 x double> %retval +} + +define <vscale x 6 x bfloat> @interleave3_nxv6bf16(<vscale x 2 x bfloat> %vec0, <vscale x 2 x bfloat> %vec1, <vscale x 2 x bfloat> %vec2) { +; CHECK-LABEL: interleave3_nxv6bf16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3d { z0.d - z2.d }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp, #2, mul vl] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp] +; CHECK-NEXT: uzp1 z0.s, z0.s, z0.s +; CHECK-NEXT: uzp1 z1.s, z2.s, z1.s +; CHECK-NEXT: uzp1 z0.h, z1.h, z0.h +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 6 x bfloat> @llvm.vector.interleave3.nxv6bf16(<vscale x 2 x bfloat> %vec0, <vscale x 2 x bfloat> %vec1, <vscale x 2 x bfloat> %vec2) + ret <vscale x 6 x bfloat> %retval +} + +define <vscale x 12 x bfloat> @interleave3_nxv12bf16(<vscale x 4 x bfloat> %vec0, <vscale x 4 x bfloat> %vec1, <vscale x 4 x bfloat> %vec2) { +; CHECK-LABEL: interleave3_nxv12bf16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-5 +; CHECK-NEXT: .cfi_escape 0x0f, 0x09, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x11, 0x28, 0x1e, 0x22 // sp + 16 + 40 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: addpl x8, sp, #4 +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3w { z0.s - z2.s }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp, #1, mul vl] +; CHECK-NEXT: ldr z1, [sp] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: uzp1 z0.h, z1.h, z0.h +; CHECK-NEXT: st1h { z2.s }, p0, [x8, #7, mul vl] +; CHECK-NEXT: str z0, [sp, #3, mul vl] +; CHECK-NEXT: ldr z1, [sp, #4, mul vl] +; CHECK-NEXT: ldr z0, [sp, #3, mul vl] +; CHECK-NEXT: addvl sp, sp, #5 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 12 x bfloat> @llvm.vector.interleave3.nxv12bf16(<vscale x 4 x bfloat> %vec0, <vscale x 4 x bfloat> %vec1, <vscale x 4 x bfloat> %vec2) + ret <vscale x 12 x bfloat> %retval +} + +define <vscale x 24 x bfloat> @interleave3_nxv24bf16(<vscale x 8 x bfloat> %vec0, <vscale x 8 x bfloat> %vec1, <vscale x 8 x bfloat> %vec2) { +; CHECK-LABEL: interleave3_nxv24bf16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3h { z0.h - z2.h }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 24 x bfloat> @llvm.vector.interleave3.nxv24bf16(<vscale x 8 x bfloat> %vec0, <vscale x 8 x bfloat> %vec1, <vscale x 8 x bfloat> %vec2) + ret <vscale x 24 x bfloat> %retval +} + +; Integers + +define <vscale x 48 x i8> @interleave3_nxv48i8(<vscale x 16 x i8> %vec0, <vscale x 16 x i8> %vec1, <vscale x 16 x i8> %vec2) { +; CHECK-LABEL: interleave3_nxv48i8: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.b +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3b { z0.b - z2.b }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 48 x i8> @llvm.vector.interleave3.nxv48i8(<vscale x 16 x i8> %vec0, <vscale x 16 x i8> %vec1, <vscale x 16 x i8> %vec2) + ret <vscale x 48 x i8> %retval +} + +define <vscale x 24 x i16> @interleave3_nxv24i16(<vscale x 8 x i16> %vec0, <vscale x 8 x i16> %vec1, <vscale x 8 x i16> %vec2) { +; CHECK-LABEL: interleave3_nxv24i16: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.h +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3h { z0.h - z2.h }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 24 x i16> @llvm.vector.interleave3.nxv24i16(<vscale x 8 x i16> %vec0, <vscale x 8 x i16> %vec1, <vscale x 8 x i16> %vec2) + ret <vscale x 24 x i16> %retval +} + +define <vscale x 12 x i32> @interleave3_nxv12i32(<vscale x 4 x i32> %vec0, <vscale x 4 x i32> %vec1, <vscale x 4 x i32> %vec2) { +; CHECK-LABEL: interleave3_nxv12i32: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.s +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3w { z0.s - z2.s }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 12 x i32> @llvm.vector.interleave3.nxv12i32(<vscale x 4 x i32> %vec0, <vscale x 4 x i32> %vec1, <vscale x 4 x i32> %vec2) + ret <vscale x 12 x i32> %retval +} + +define <vscale x 6 x i64> @interleave3_nxv6i64(<vscale x 2 x i64> %vec0, <vscale x 2 x i64> %vec1, <vscale x 2 x i64> %vec2) { +; CHECK-LABEL: interleave3_nxv6i64: +; CHECK: // %bb.0: +; CHECK-NEXT: str x29, [sp, #-16]! // 8-byte Folded Spill +; CHECK-NEXT: addvl sp, sp, #-3 +; CHECK-NEXT: .cfi_escape 0x0f, 0x08, 0x8f, 0x10, 0x92, 0x2e, 0x00, 0x48, 0x1e, 0x22 // sp + 16 + 24 * VG +; CHECK-NEXT: .cfi_offset w29, -16 +; CHECK-NEXT: // kill: def $z2 killed $z2 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: ptrue p0.d +; CHECK-NEXT: // kill: def $z1 killed $z1 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: // kill: def $z0 killed $z0 killed $z0_z1_z2 def $z0_z1_z2 +; CHECK-NEXT: st3d { z0.d - z2.d }, p0, [sp] +; CHECK-NEXT: ldr z0, [sp] +; CHECK-NEXT: ldr z1, [sp, #1, mul vl] +; CHECK-NEXT: ldr z2, [sp, #2, mul vl] +; CHECK-NEXT: addvl sp, sp, #3 +; CHECK-NEXT: ldr x29, [sp], #16 // 8-byte Folded Reload +; CHECK-NEXT: ret + %retval = call <vscale x 6 x i64> @llvm.vector.interleave3.nxv6i64(<vscale x 2 x i64> %vec0, <vscale x 2 x i64> %vec1, <vscale x 2 x i64> %vec2) + ret <vscale x 6 x i64> %retval +} + define <vscale x 64 x i8> @interleave4_nxv16i8(<vscale x 16 x i8> %vec0, <vscale x 16 x i8> %vec1, <vscale x 16 x i8> %vec2, <vscale x 16 x i8> %vec3) { ; SVE-LABEL: interleave4_nxv16i8: ; SVE: // %bb.0: diff --git a/llvm/test/CodeGen/AArch64/vecreduce-fadd-strict.ll b/llvm/test/CodeGen/AArch64/vecreduce-fadd-strict.ll index be07978..8e0328e 100644 --- a/llvm/test/CodeGen/AArch64/vecreduce-fadd-strict.ll +++ b/llvm/test/CodeGen/AArch64/vecreduce-fadd-strict.ll @@ -38,17 +38,11 @@ define half @add_v2HalfH(<2 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: add_v2HalfH: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI1_0 ; CHECK-GI-NOFP16-NEXT: // kill: def $d0 killed $d0 def $q0 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h0 -; CHECK-GI-NOFP16-NEXT: ldr h1, [x8, :lo12:.LCPI1_0] -; CHECK-GI-NOFP16-NEXT: mov h0, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 +; CHECK-GI-NOFP16-NEXT: mov h1, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s0, h0 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 -; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s0, s1, s0 +; CHECK-GI-NOFP16-NEXT: fadd s0, s0, s1 ; CHECK-GI-NOFP16-NEXT: fcvt h0, s0 ; CHECK-GI-NOFP16-NEXT: ret ; @@ -88,19 +82,13 @@ define half @add_v3HalfH(<3 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: add_v3HalfH: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI2_0 ; CHECK-GI-NOFP16-NEXT: // kill: def $d0 killed $d0 def $q0 +; CHECK-GI-NOFP16-NEXT: mov h1, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s2, h0 -; CHECK-GI-NOFP16-NEXT: ldr h1, [x8, :lo12:.LCPI2_0] -; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 -; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] ; CHECK-GI-NOFP16-NEXT: mov h0, v0.h[2] -; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 -; CHECK-GI-NOFP16-NEXT: fcvt s0, h0 ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 +; CHECK-GI-NOFP16-NEXT: fcvt s0, h0 +; CHECK-GI-NOFP16-NEXT: fadd s1, s2, s1 ; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 ; CHECK-GI-NOFP16-NEXT: fadd s0, s1, s0 @@ -152,17 +140,11 @@ define half @add_HalfH(<4 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: add_HalfH: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI3_0 ; CHECK-GI-NOFP16-NEXT: // kill: def $d0 killed $d0 def $q0 +; CHECK-GI-NOFP16-NEXT: mov h1, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s2, h0 -; CHECK-GI-NOFP16-NEXT: ldr h1, [x8, :lo12:.LCPI3_0] -; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 -; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 +; CHECK-GI-NOFP16-NEXT: fadd s1, s2, s1 ; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[2] ; CHECK-GI-NOFP16-NEXT: mov h0, v0.h[3] ; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 @@ -250,16 +232,10 @@ define half @add_H(<8 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: add_H: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI4_0 +; CHECK-GI-NOFP16-NEXT: mov h1, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s2, h0 -; CHECK-GI-NOFP16-NEXT: ldr h1, [x8, :lo12:.LCPI4_0] -; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 -; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fadd s1, s1, s2 +; CHECK-GI-NOFP16-NEXT: fadd s1, s2, s1 ; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[2] ; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 ; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 @@ -448,16 +424,10 @@ define half @add_2H(<16 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: add_2H: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI7_0 +; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s3, h0 -; CHECK-GI-NOFP16-NEXT: ldr h2, [x8, :lo12:.LCPI7_0] -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 -; CHECK-GI-NOFP16-NEXT: fadd s2, s2, s3 -; CHECK-GI-NOFP16-NEXT: mov h3, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt h2, s2 -; CHECK-GI-NOFP16-NEXT: fcvt s3, h3 ; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 -; CHECK-GI-NOFP16-NEXT: fadd s2, s2, s3 +; CHECK-GI-NOFP16-NEXT: fadd s2, s3, s2 ; CHECK-GI-NOFP16-NEXT: mov h3, v0.h[2] ; CHECK-GI-NOFP16-NEXT: fcvt h2, s2 ; CHECK-GI-NOFP16-NEXT: fcvt s3, h3 diff --git a/llvm/test/CodeGen/AArch64/vecreduce-fmul-strict.ll b/llvm/test/CodeGen/AArch64/vecreduce-fmul-strict.ll index c10d6e9..716401e 100644 --- a/llvm/test/CodeGen/AArch64/vecreduce-fmul-strict.ll +++ b/llvm/test/CodeGen/AArch64/vecreduce-fmul-strict.ll @@ -52,17 +52,11 @@ define half @mul_HalfH(<4 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: mul_HalfH: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI1_0 ; CHECK-GI-NOFP16-NEXT: // kill: def $d0 killed $d0 def $q0 +; CHECK-GI-NOFP16-NEXT: mov h1, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s2, h0 -; CHECK-GI-NOFP16-NEXT: ldr h1, [x8, :lo12:.LCPI1_0] ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fmul s1, s1, s2 -; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 -; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fmul s1, s1, s2 +; CHECK-GI-NOFP16-NEXT: fmul s1, s2, s1 ; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[2] ; CHECK-GI-NOFP16-NEXT: mov h0, v0.h[3] ; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 @@ -144,16 +138,10 @@ define half @mul_H(<8 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: mul_H: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI2_0 +; CHECK-GI-NOFP16-NEXT: mov h1, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s2, h0 -; CHECK-GI-NOFP16-NEXT: ldr h1, [x8, :lo12:.LCPI2_0] -; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fmul s1, s1, s2 -; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 ; CHECK-GI-NOFP16-NEXT: fcvt s1, h1 -; CHECK-GI-NOFP16-NEXT: fmul s1, s1, s2 +; CHECK-GI-NOFP16-NEXT: fmul s1, s2, s1 ; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[2] ; CHECK-GI-NOFP16-NEXT: fcvt h1, s1 ; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 @@ -321,16 +309,10 @@ define half @mul_2H(<16 x half> %bin.rdx) { ; ; CHECK-GI-NOFP16-LABEL: mul_2H: ; CHECK-GI-NOFP16: // %bb.0: -; CHECK-GI-NOFP16-NEXT: adrp x8, .LCPI5_0 +; CHECK-GI-NOFP16-NEXT: mov h2, v0.h[1] ; CHECK-GI-NOFP16-NEXT: fcvt s3, h0 -; CHECK-GI-NOFP16-NEXT: ldr h2, [x8, :lo12:.LCPI5_0] ; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 -; CHECK-GI-NOFP16-NEXT: fmul s2, s2, s3 -; CHECK-GI-NOFP16-NEXT: mov h3, v0.h[1] -; CHECK-GI-NOFP16-NEXT: fcvt h2, s2 -; CHECK-GI-NOFP16-NEXT: fcvt s3, h3 -; CHECK-GI-NOFP16-NEXT: fcvt s2, h2 -; CHECK-GI-NOFP16-NEXT: fmul s2, s2, s3 +; CHECK-GI-NOFP16-NEXT: fmul s2, s3, s2 ; CHECK-GI-NOFP16-NEXT: mov h3, v0.h[2] ; CHECK-GI-NOFP16-NEXT: fcvt h2, s2 ; CHECK-GI-NOFP16-NEXT: fcvt s3, h3 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/fdiv.f16.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/fdiv.f16.ll index 1aee6ab..1b879a6 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/fdiv.f16.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/fdiv.f16.ll @@ -403,40 +403,38 @@ define half @v_neg_rcp_f16(half %x) { ; GFX6-IEEE-LABEL: v_neg_rcp_f16: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_neg_rcp_f16: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] @@ -460,40 +458,38 @@ define half @v_rcp_f16(half %x) { ; GFX6-IEEE-LABEL: v_rcp_f16: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_rcp_f16: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] @@ -517,40 +513,38 @@ define half @v_rcp_f16_arcp(half %x) { ; GFX6-IEEE-LABEL: v_rcp_f16_arcp: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_rcp_f16_arcp: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] @@ -575,9 +569,7 @@ define half @v_rcp_f16_arcp_afn(half %x) { ; GFX6: ; %bb.0: ; GFX6-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-NEXT: v_rcp_f32_e32 v0, v0 -; GFX6-NEXT: v_mul_f32_e32 v0, v1, v0 ; GFX6-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-NEXT: s_setpc_b64 s[30:31] ; @@ -600,40 +592,38 @@ define half @v_rcp_f16_ulp25(half %x) { ; GFX6-IEEE-LABEL: v_rcp_f16_ulp25: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_rcp_f16_ulp25: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] @@ -1454,70 +1444,67 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX6-IEEE-LABEL: v_rcp_v2f16: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v1, v1, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v1, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_rcp_v2f16: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -1526,30 +1513,27 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX8-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v6, -v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, 1.0, v1 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v4, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -1561,26 +1545,23 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX8-FLUSH-LABEL: v_rcp_v2f16: ; GFX8-FLUSH: ; %bb.0: ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v8, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v9, v8, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, -v1, v4, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v6, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v9 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -1594,30 +1575,27 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX9-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v6, -v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, 1.0, v1 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v4, v7, v5 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -1628,26 +1606,24 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX9-FLUSH-LABEL: v_rcp_v2f16: ; GFX9-FLUSH: ; %bb.0: ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v1, v1 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v3, v3 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v1 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v6, v1 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, -v0, v1, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v3, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v5, v5, v1, v1 +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v3, v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v4, -v0, v6, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v1, v7, v1 +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v4, v6, v3 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v1, v1, v5 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v5, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v1, v1, v5 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -1660,30 +1636,27 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v9, v9, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v10, v10, v6 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v9, v9, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v10, v10, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v6, -v2, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, 1.0, v2 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 @@ -1696,24 +1669,21 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, -v2, v4, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 @@ -1726,27 +1696,25 @@ define <2 x half> @v_rcp_v2f16(<2 x half> %x) { ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX11-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX11-NEXT: v_rcp_f32_e32 v2, v2 ; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX11-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX11-NEXT: v_mul_f32_e32 v3, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v2, v6, v2 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_dual_add_f32 v3, v3, v4 :: v_dual_and_b32 v2, 0xff800000, v2 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 -; GFX11-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 +; GFX11-NEXT: v_fma_mix_f32 v5, -v0, v2, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v3, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v5, v5, v2, v2 +; GFX11-NEXT: v_fma_f32 v6, v6, v3, v3 +; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v4, -v0, v6, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_dual_mul_f32 v2, v7, v2 :: v_dual_mul_f32 v3, v4, v3 +; GFX11-NEXT: v_and_b32_e32 v2, 0xff800000, v2 +; GFX11-NEXT: v_dual_add_f32 v2, v2, v5 :: v_dual_and_b32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX11-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 +; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v0, v1 ; GFX11-NEXT: s_setpc_b64 s[30:31] %fdiv = fdiv <2 x half> <half 1.0, half 1.0>, %x @@ -1757,70 +1725,67 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX6-IEEE-LABEL: v_neg_rcp_v2f16: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v1, v1, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v1, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, -1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, -1.0, v1, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_neg_rcp_v2f16: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, -1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v1, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -1829,30 +1794,27 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX8-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, -1.0, v1 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v4, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -1864,26 +1826,23 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX8-FLUSH-LABEL: v_neg_rcp_v2f16: ; GFX8-FLUSH: ; %bb.0: ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v8, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v9, v8, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v1, v4, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v6, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v9 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -1897,30 +1856,27 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX9-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX9-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, -1.0, v1 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX9-IEEE-NEXT: v_sub_f32_e32 v4, v7, v5 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -1931,26 +1887,24 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX9-FLUSH-LABEL: v_neg_rcp_v2f16: ; GFX9-FLUSH: ; %bb.0: ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v1, v1 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v3, v3 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v1 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v6, v1 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v4, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, v0, v1, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, v0, v3, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v5, v5, v1, -v1 +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v3, -v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v4, -v0, v6, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v1, v7, v1 +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v4, v6, v3 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v1, v1, v5 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, -v0, v4, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v5, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v1, v1, v5 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -1963,30 +1917,27 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v6, -1.0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v9, v9, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v10, v10, v6 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v9, v9, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v10, v10, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v2, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_sub_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, -1.0, v2 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -1999,24 +1950,21 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, -1.0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v2, v4, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -2029,27 +1977,25 @@ define <2 x half> @v_neg_rcp_v2f16(<2 x half> %x) { ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX11-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX11-NEXT: v_rcp_f32_e32 v2, v2 ; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX11-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v4, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v4, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX11-NEXT: v_mul_f32_e32 v3, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v2, v6, v2 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_dual_add_f32 v3, v3, v4 :: v_dual_and_b32 v2, 0xff800000, v2 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 -; GFX11-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 +; GFX11-NEXT: v_fma_mix_f32 v5, v0, v2, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v6, v0, v3, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v5, v5, v2, -v2 +; GFX11-NEXT: v_fma_f32 v6, v6, v3, -v3 +; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v4, -v0, v6, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_dual_mul_f32 v2, v7, v2 :: v_dual_mul_f32 v3, v4, v3 +; GFX11-NEXT: v_and_b32_e32 v2, 0xff800000, v2 +; GFX11-NEXT: v_dual_add_f32 v2, v2, v5 :: v_dual_and_b32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX11-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 +; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v0, v1 ; GFX11-NEXT: s_setpc_b64 s[30:31] %fdiv = fdiv <2 x half> <half -1.0, half -1.0>, %x @@ -2064,33 +2010,32 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX6-IEEE-NEXT: v_and_b32_e32 v0, 0xffff, v0 ; GFX6-IEEE-NEXT: v_or_b32_e32 v0, v1, v0 ; GFX6-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX6-IEEE-NEXT: v_lshrrev_b32_e32 v0, 16, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v2, v2, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v1, v2, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v5, v0 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v0, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v0, v2, v1 -; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v5, v5, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 ; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v5, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v2, v6, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v6, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v5, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v4, v0 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v0, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v0, v1, 1.0 +; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v4, v4, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v4, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v5, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v1, v5, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v2, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v5, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v1, v4, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -2101,39 +2046,37 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX6-FLUSH-NEXT: v_and_b32_e32 v0, 0xffff, v0 ; GFX6-FLUSH-NEXT: v_or_b32_e32 v0, v1, v0 ; GFX6-FLUSH-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX6-FLUSH-NEXT: v_lshrrev_b32_e32 v0, 16, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v2, v2, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v1, v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v5, v0 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v2, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v5, v5, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v3, v3, 1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, v4, v5, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v3, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v1, v2, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, v6, v2, v2 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v3, v2 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v1, v6, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v2, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v6, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v5, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v1, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v2, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v1, v5, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v1, v3, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -2143,30 +2086,27 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX8-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v6, -v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, 1.0, v1 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v4, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -2179,26 +2119,23 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX8-FLUSH: ; %bb.0: ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-FLUSH-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v8, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v9, v8, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, -v1, v4, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v6, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v9 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -2213,30 +2150,27 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX9-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v6, -v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, 1.0, v1 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v4, v7, v5 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -2248,26 +2182,24 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX9-FLUSH: ; %bb.0: ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-FLUSH-NEXT: v_and_b32_e32 v1, 0x7fff7fff, v0 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-FLUSH-NEXT: v_lshrrev_b32_e32 v3, 16, v1 +; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, v3 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v5, 1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v5, 1.0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v4, v4 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v2 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v1, v6, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v5, v4 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v6, v7, v2 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -|v0|, v5, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v7, v4 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v8, -v1, v6, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v0, -|v0|, v5, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v2, v5 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -|v0|, v4, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v2, v2 +; GFX9-FLUSH-NEXT: v_mad_f32 v7, v7, v4, v4 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v8, -v1, v6, v5 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v0, -|v0|, v7, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v8, v2 ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v0, v0, v4 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v0, 0xff800000, v0 ; GFX9-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v0, v0, v5 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v0, v0, v7 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v1, v2, v1, 1.0 @@ -2279,32 +2211,29 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX10-IEEE: ; %bb.0: ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-IEEE-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v9, v9, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v10, v10, v6 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v9, v9, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v10, v10, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v6, -v2, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, 1.0, v2 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 @@ -2316,26 +2245,23 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX10-FLUSH: ; %bb.0: ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-FLUSH-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, -v2, v4, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 @@ -2346,30 +2272,30 @@ define <2 x half> @v_rcp_v2f16_fabs(<2 x half> %x) { ; GFX11-LABEL: v_rcp_v2f16_fabs: ; GFX11: ; %bb.0: ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX11-NEXT: v_cvt_f32_f16_e32 v5, 1.0 ; GFX11-NEXT: v_and_b32_e32 v1, 0x7fff7fff, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 -; GFX11-NEXT: v_rcp_f32_e32 v3, v3 -; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v6, v5, v3 ; GFX11-NEXT: v_lshrrev_b32_e32 v2, 16, v1 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v6, 1.0 op_sel_hi:[1,0,1] ; GFX11-NEXT: v_cvt_f32_f16_e32 v4, v2 -; GFX11-NEXT: v_fmac_f32_e32 v6, v7, v3 ; GFX11-NEXT: v_rcp_f32_e32 v4, v4 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v6, 1.0 op_sel_hi:[1,0,1] +; GFX11-NEXT: v_mov_b32_e32 v5, 1.0 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v5, v4 -; GFX11-NEXT: v_fma_mix_f32 v8, -|v0|, v5, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v8, v4 -; GFX11-NEXT: v_fma_mix_f32 v0, -|v0|, v5, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v3, v7, v3 :: v_dual_mul_f32 v0, v0, v4 +; GFX11-NEXT: v_fma_mix_f32 v7, -|v0|, v4, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v7, v7, v4, v4 +; GFX11-NEXT: v_fma_mix_f32 v0, -|v0|, v7, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_mul_f32_e32 v0, v0, v4 ; GFX11-NEXT: v_and_b32_e32 v0, 0xff800000, v0 -; GFX11-NEXT: v_dual_add_f32 v0, v0, v5 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX11-NEXT: v_add_f32_e32 v0, v0, v7 +; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX11-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 +; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v0, v2, 1.0 +; GFX11-NEXT: s_waitcnt_depctr 0xfff +; GFX11-NEXT: v_fma_mix_f32 v6, -v1, v3, v5 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v6, v6, v3, v3 +; GFX11-NEXT: v_fma_mix_f32 v8, -v1, v6, v5 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_mul_f32_e32 v3, v8, v3 +; GFX11-NEXT: v_and_b32_e32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v1, v0 ; GFX11-NEXT: s_setpc_b64 s[30:31] @@ -2386,33 +2312,32 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX6-IEEE-NEXT: v_and_b32_e32 v0, 0xffff, v0 ; GFX6-IEEE-NEXT: v_or_b32_e32 v0, v1, v0 ; GFX6-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX6-IEEE-NEXT: v_lshrrev_b32_e32 v0, 16, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v2, v2, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v1, v2, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v5, v0 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v0, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v0, v2, v1 -; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v5, v5, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, -1.0 ; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v5, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v2, v6, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v6, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v5, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, -1.0, v1, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v4, v0 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v0, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v0, v1, -1.0 +; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v4, v4, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v4, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v5, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v1, v5, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v2, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v5, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v1, v4, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -2423,39 +2348,37 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX6-FLUSH-NEXT: v_and_b32_e32 v0, 0xffff, v0 ; GFX6-FLUSH-NEXT: v_or_b32_e32 v0, v1, v0 ; GFX6-FLUSH-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX6-FLUSH-NEXT: v_lshrrev_b32_e32 v0, 16, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v2, v2, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v1, v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v1, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v5, v0 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v2, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v1, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v5, v5, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v3, v3, -1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, v4, v5, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v3, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v1, v2, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, v6, v2, v2 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v3, v2 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v1, v6, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v2, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v6, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v5, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v1, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v2, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v1, v5, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v1, v3, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -2465,30 +2388,27 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX8-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, -1.0, v1 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v4, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -2501,26 +2421,23 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX8-FLUSH: ; %bb.0: ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-FLUSH-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v8, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v9, v8, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v1, v4, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v6, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v9 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -2535,30 +2452,27 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX9-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX9-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, -1.0, v1 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX9-IEEE-NEXT: v_sub_f32_e32 v4, v7, v5 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, -1.0 @@ -2570,26 +2484,24 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX9-FLUSH: ; %bb.0: ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-FLUSH-NEXT: v_and_b32_e32 v1, 0x7fff7fff, v0 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-FLUSH-NEXT: v_lshrrev_b32_e32 v3, 16, v1 +; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, v3 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v5, -1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v5, -1.0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v4, v4 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v2 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v1, v6, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v5, v4 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v6, v7, v2 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -|v0|, v5, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v7, v4 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v8, -v1, v6, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v0, -|v0|, v5, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, v1, v2, v5 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, |v0|, v4, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v2, -v2 +; GFX9-FLUSH-NEXT: v_mad_f32 v7, v7, v4, -v4 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v8, -v1, v6, v5 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v0, -|v0|, v7, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v8, v2 ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v0, v0, v4 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v0, 0xff800000, v0 ; GFX9-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v0, v0, v5 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v0, v0, v7 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v1, v2, v1, -1.0 @@ -2601,32 +2513,29 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX10-IEEE: ; %bb.0: ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v6, -1.0 ; GFX10-IEEE-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v9, v9, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v10, v10, v6 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v9, v9, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v10, v10, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v2, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_sub_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, -1.0, v2 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -2638,26 +2547,23 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX10-FLUSH: ; %bb.0: ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_and_b32_e32 v0, 0x7fff7fff, v0 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, -1.0 ; GFX10-FLUSH-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v2, v4, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -2668,30 +2574,30 @@ define <2 x half> @v_neg_rcp_v2f16_fabs(<2 x half> %x) { ; GFX11-LABEL: v_neg_rcp_v2f16_fabs: ; GFX11: ; %bb.0: ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX11-NEXT: v_cvt_f32_f16_e32 v5, -1.0 ; GFX11-NEXT: v_and_b32_e32 v1, 0x7fff7fff, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 -; GFX11-NEXT: v_rcp_f32_e32 v3, v3 -; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v6, v5, v3 ; GFX11-NEXT: v_lshrrev_b32_e32 v2, 16, v1 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v6, -1.0 op_sel_hi:[1,0,1] ; GFX11-NEXT: v_cvt_f32_f16_e32 v4, v2 -; GFX11-NEXT: v_fmac_f32_e32 v6, v7, v3 ; GFX11-NEXT: v_rcp_f32_e32 v4, v4 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v6, -1.0 op_sel_hi:[1,0,1] +; GFX11-NEXT: v_mov_b32_e32 v5, -1.0 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v5, v4 -; GFX11-NEXT: v_fma_mix_f32 v8, -|v0|, v5, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v8, v4 -; GFX11-NEXT: v_fma_mix_f32 v0, -|v0|, v5, -1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v3, v7, v3 :: v_dual_mul_f32 v0, v0, v4 +; GFX11-NEXT: v_fma_mix_f32 v7, |v0|, v4, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v7, v7, v4, -v4 +; GFX11-NEXT: v_fma_mix_f32 v0, -|v0|, v7, v5 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_mul_f32_e32 v0, v0, v4 ; GFX11-NEXT: v_and_b32_e32 v0, 0xff800000, v0 -; GFX11-NEXT: v_dual_add_f32 v0, v0, v5 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX11-NEXT: v_add_f32_e32 v0, v0, v7 +; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX11-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 +; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v0, v2, -1.0 +; GFX11-NEXT: s_waitcnt_depctr 0xfff +; GFX11-NEXT: v_fma_mix_f32 v6, v1, v3, v5 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v6, v6, v3, -v3 +; GFX11-NEXT: v_fma_mix_f32 v8, -v1, v6, v5 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_mul_f32_e32 v3, v8, v3 +; GFX11-NEXT: v_and_b32_e32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v1, v0 ; GFX11-NEXT: s_setpc_b64 s[30:31] @@ -2704,70 +2610,67 @@ define <2 x half> @v_rcp_v2f16_arcp(<2 x half> %x) { ; GFX6-IEEE-LABEL: v_rcp_v2f16_arcp: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v1, v1, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v1, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_rcp_v2f16_arcp: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -2814,11 +2717,8 @@ define <2 x half> @v_rcp_v2f16_arcp_afn(<2 x half> %x) { ; GFX6-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-NEXT: v_rcp_f32_e32 v0, v0 ; GFX6-NEXT: v_rcp_f32_e32 v1, v1 -; GFX6-NEXT: v_mul_f32_e32 v0, v2, v0 -; GFX6-NEXT: v_mul_f32_e32 v1, v2, v1 ; GFX6-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-NEXT: s_setpc_b64 s[30:31] @@ -2864,70 +2764,67 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX6-IEEE-LABEL: v_rcp_v2f16_ulp25: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v1, v1, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v2, v1, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; ; GFX6-FLUSH-LABEL: v_rcp_v2f16_ulp25: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -2936,30 +2833,27 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX8-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v6, -v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, 1.0, v1 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v4, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -2971,26 +2865,23 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX8-FLUSH-LABEL: v_rcp_v2f16_ulp25: ; GFX8-FLUSH: ; %bb.0: ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v1 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v8, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v9, v8, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v7, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v1 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, -v1, v4, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v1, -v1, v6, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v9 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -3004,30 +2895,27 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX9-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_lshrrev_b32_e32 v2, 16, v0 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v1 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v8, -v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v7 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v10, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v5, v5, v6 -; GFX9-IEEE-NEXT: v_add_f32_e32 v5, v5, v9 -; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v1 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v6, -v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v1, -v1, v6 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, 1.0, v1 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v1, v1, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v4, v7, v5 +; GFX9-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v4 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v1, 0xff800000, v1 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 +; GFX9-IEEE-NEXT: v_add_f32_e32 v1, v1, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -3038,26 +2926,24 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX9-FLUSH-LABEL: v_rcp_v2f16_ulp25: ; GFX9-FLUSH: ; %bb.0: ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_lshrrev_b32_e32 v2, 16, v0 +; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v2 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v1, v1 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v3, v3 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v1 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v6, v1 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, -v0, v1, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v3, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v5, v5, v1, v1 +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v3, v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v4, -v0, v6, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v1, v7, v1 +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v1, 0xff800000, v1 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v4, v6, v3 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v1, v1, v5 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v5, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v1, v1, v5 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v0, v1, v0, 1.0 @@ -3070,30 +2956,27 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v9, v9, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v10, v10, v6 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v9, v9, v4 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v10, v10, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v6, -v2, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX10-IEEE-NEXT: v_add_f32_e32 v7, v7, v5 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX10-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, 1.0, v2 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 @@ -3106,24 +2989,21 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, -v2, v4, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 @@ -3136,27 +3016,25 @@ define <2 x half> @v_rcp_v2f16_ulp25(<2 x half> %x) { ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX11-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX11-NEXT: v_rcp_f32_e32 v2, v2 ; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX11-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v4, 1.0 op_sel:[1,0,0] op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX11-NEXT: v_mul_f32_e32 v3, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v2, v6, v2 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_dual_add_f32 v3, v3, v4 :: v_dual_and_b32 v2, 0xff800000, v2 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 -; GFX11-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 +; GFX11-NEXT: v_fma_mix_f32 v5, -v0, v2, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v3, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v5, v5, v2, v2 +; GFX11-NEXT: v_fma_f32 v6, v6, v3, v3 +; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v4, -v0, v6, v4 op_sel:[1,0,0] op_sel_hi:[1,0,0] +; GFX11-NEXT: v_dual_mul_f32 v2, v7, v2 :: v_dual_mul_f32 v3, v4, v3 +; GFX11-NEXT: v_and_b32_e32 v2, 0xff800000, v2 +; GFX11-NEXT: v_dual_add_f32 v2, v2, v5 :: v_dual_and_b32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX11-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 +; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v0, v1 ; GFX11-NEXT: s_setpc_b64 s[30:31] %fdiv = fdiv <2 x half> <half 1.0, half 1.0>, %x @@ -4033,40 +3911,38 @@ define amdgpu_ps i32 @s_fdiv_v2f16(i32 inreg %a.arg, i32 inreg %b.arg) { define amdgpu_ps i16 @s_rcp_f16(i16 inreg %a.arg) { ; GFX6-IEEE-LABEL: s_rcp_f16: ; GFX6-IEEE: ; %bb.0: -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, 1.0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, s0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[0:1], v1, v1, v0 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v0, v1, v0 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v1, v0 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, s0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[0:1], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_readfirstlane_b32 s0, v0 ; GFX6-IEEE-NEXT: ; return to shader part epilog ; ; GFX6-FLUSH-LABEL: s_rcp_f16: ; GFX6-FLUSH: ; %bb.0: -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, 1.0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, s0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[0:1], v1, v1, v0 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v0, v1, v0 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, s0 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[0:1], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v1, v0 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_readfirstlane_b32 s0, v0 @@ -4099,40 +3975,38 @@ define amdgpu_ps i16 @s_rcp_f16(i16 inreg %a.arg) { define amdgpu_ps i16 @s_neg_rcp_f16(i16 inreg %a.arg) { ; GFX6-IEEE-LABEL: s_neg_rcp_f16: ; GFX6-IEEE: ; %bb.0: -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, -1.0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, s0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[0:1], v1, v1, v0 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v0, v1, v0 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v1, v0 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, s0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[0:1], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_readfirstlane_b32 s0, v0 ; GFX6-IEEE-NEXT: ; return to shader part epilog ; ; GFX6-FLUSH-LABEL: s_neg_rcp_f16: ; GFX6-FLUSH: ; %bb.0: -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, -1.0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, s0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[0:1], v1, v1, v0 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v0, v1, v0 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, s0 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[0:1], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v1, v0 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_readfirstlane_b32 s0, v0 @@ -4166,21 +4040,20 @@ define amdgpu_ps i16 @s_rsq_f16(i16 inreg %a.arg) { ; GFX6-IEEE-LABEL: s_rsq_f16: ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, s0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[0:1], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[0:1], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_readfirstlane_b32 s0, v0 ; GFX6-IEEE-NEXT: ; return to shader part epilog @@ -4188,24 +4061,23 @@ define amdgpu_ps i16 @s_rsq_f16(i16 inreg %a.arg) { ; GFX6-FLUSH-LABEL: s_rsq_f16: ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, s0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[0:1], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[0:1], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_readfirstlane_b32 s0, v0 ; GFX6-FLUSH-NEXT: ; return to shader part epilog @@ -4241,36 +4113,35 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, s0 ; GFX6-IEEE-NEXT: s_lshr_b32 s0, s0, 16 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, s0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[0:1], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v5, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v6, s[0:1], v1, v1, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v9, -v3, v5, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v9, v5, v5 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v9, v4, v5 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v8, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v10, -v3, v9, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v9, v10, v5, v9 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v9, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v5, v9 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v6, v8, 1.0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v7, s[0:1], v2, v1, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v3, v8, v8 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v7, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v6, v4, v7 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v3, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v6, v4, v7 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[0:1], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v5, s[0:1], v1, v1, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v8, -v2, v4, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v8, v4, v4 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v6, v5 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v9, v3, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v10, -v2, v9, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v9, v10, v4, v9 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v9, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v8, -v5, v6, 1.0 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v4, v9 +; GFX6-IEEE-NEXT: v_div_scale_f32 v7, s[0:1], -1.0, v1, -1.0 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v8, v6, v6 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v3, v7, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v5, v3, v7 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v4, v2, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v5, v3, v7 ; GFX6-IEEE-NEXT: s_mov_b64 vcc, s[0:1] -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v5, v3, v4 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v4, v2, v3 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_lshlrev_b32_e32 v1, 16, v1 @@ -4283,42 +4154,40 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, s0 ; GFX6-FLUSH-NEXT: s_lshr_b32 s0, s0, 16 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, s0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[0:1], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[0:1], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[0:1], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[0:1], v1, v1, -1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v1, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: v_lshlrev_b32_e32 v1, 16, v1 ; GFX6-FLUSH-NEXT: v_or_b32_e32 v0, v0, v1 @@ -4330,31 +4199,28 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX8-IEEE-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX8-IEEE-NEXT: s_lshr_b32 s0, s0, 16 ; GFX8-IEEE-NEXT: v_sqrt_f16_e32 v1, s0 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v8, -v2, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v8, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v8, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v9 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v8, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v10, v10, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v10, v6 -; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v2, v2, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v5, v8, v9 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v2, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 +; GFX8-IEEE-NEXT: v_add_f32_e32 v2, -1.0, v2 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX8-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 @@ -4369,25 +4235,22 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX8-FLUSH-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX8-FLUSH-NEXT: s_lshr_b32 s0, s0, 16 ; GFX8-FLUSH-NEXT: v_sqrt_f16_e32 v1, s0 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v2 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v2, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v8, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v8, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v9, v8, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v9, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v5 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v2, v4, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, -1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v9 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 @@ -4402,25 +4265,22 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX9-IEEE-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX9-IEEE-NEXT: s_lshr_b32 s0, s0, 16 ; GFX9-IEEE-NEXT: v_sqrt_f16_e32 v1, s0 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_fma_f32 v8, -v2, v7, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX9-IEEE-NEXT: v_fma_f32 v7, v8, v5, v7 -; GFX9-IEEE-NEXT: v_fma_f32 v8, -v3, v9, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v8, v8, v6, v9 -; GFX9-IEEE-NEXT: v_fma_f32 v2, -v2, v7, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v3, -v3, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v2, v2, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_fma_f32 v6, v2, v4, -1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v6, v6, v4, -v4 +; GFX9-IEEE-NEXT: v_fma_f32 v7, v3, v5, -1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v7, v7, v5, -v5 +; GFX9-IEEE-NEXT: v_fma_f32 v2, -v2, v6, -1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v3, -v3, v7, -1.0 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX9-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -4434,25 +4294,23 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX9-FLUSH-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX9-FLUSH-NEXT: s_lshr_b32 s0, s0, 16 ; GFX9-FLUSH-NEXT: v_sqrt_f16_e32 v1, s0 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v3, v3 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v6, v2 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v4, v6, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v4, -1.0 op_sel_hi:[1,0,1] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, v0, v2, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v5, v5, v2, -v2 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, v1, v3, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v3, -v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v4, -v1, v6, v4 op_sel_hi:[1,0,0] ; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v7, v2 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v6, v3 +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX9-FLUSH-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -4466,25 +4324,23 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX10-IEEE-NEXT: s_lshr_b32 s1, s0, 16 ; GFX10-IEEE-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX10-IEEE-NEXT: v_sqrt_f16_e32 v1, s1 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX10-IEEE-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v3, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX10-IEEE-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v6, v2 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v7, v3 +; GFX10-IEEE-NEXT: v_fma_mix_f32 v5, v0, v2, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, v1, v3, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_f32 v5, v5, v2, -v2 +; GFX10-IEEE-NEXT: v_fma_f32 v6, v6, v3, -v3 +; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_mix_f32 v4, -v1, v6, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v7, v2 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -4498,25 +4354,22 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX10-FLUSH-NEXT: s_lshr_b32 s1, s0, 16 ; GFX10-FLUSH-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX10-FLUSH-NEXT: v_sqrt_f16_e32 v1, s1 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, -1.0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v2, v4, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 @@ -4530,29 +4383,27 @@ define amdgpu_ps i32 @s_rsq_v2f16(i32 inreg %a.arg) { ; GFX11-NEXT: s_lshr_b32 s1, s0, 16 ; GFX11-NEXT: v_sqrt_f16_e32 v0, s0 ; GFX11-NEXT: v_sqrt_f16_e32 v1, s1 -; GFX11-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX11-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX11-NEXT: s_waitcnt_depctr 0xfff ; GFX11-NEXT: v_cvt_f32_f16_e32 v2, v0 ; GFX11-NEXT: v_cvt_f32_f16_e32 v3, v1 ; GFX11-NEXT: v_rcp_f32_e32 v2, v2 ; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX11-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX11-NEXT: v_mul_f32_e32 v3, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v2, v6, v2 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_dual_add_f32 v3, v3, v4 :: v_dual_and_b32 v2, 0xff800000, v2 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 -; GFX11-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 +; GFX11-NEXT: v_fma_mix_f32 v5, v0, v2, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v6, v1, v3, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v5, v5, v2, -v2 +; GFX11-NEXT: v_fma_f32 v6, v6, v3, -v3 +; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v4, -v1, v6, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_dual_mul_f32 v2, v7, v2 :: v_dual_mul_f32 v3, v4, v3 +; GFX11-NEXT: v_and_b32_e32 v2, 0xff800000, v2 +; GFX11-NEXT: v_dual_add_f32 v2, v2, v5 :: v_dual_and_b32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX11-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 +; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v0, v1 ; GFX11-NEXT: v_readfirstlane_b32 s0, v0 ; GFX11-NEXT: ; return to shader part epilog @@ -4568,21 +4419,20 @@ define half @v_rsq_f16(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -4590,24 +4440,23 @@ define half @v_rsq_f16(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -4632,21 +4481,20 @@ define half @v_neg_rsq_f16(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -4654,24 +4502,23 @@ define half @v_neg_rsq_f16(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -4706,21 +4553,20 @@ define { half, half } @v_rsq_f16_multi_use(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v2, v2, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, vcc, v1, v2, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v6, v5 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v2, v1 +; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -4728,24 +4574,23 @@ define { half, half } @v_rsq_f16_multi_use(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v2, v2, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v1, v2, v1 +; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v0 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v3, v2, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -4785,21 +4630,20 @@ define half @v_rsq_f16_missing_contract0(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -4807,24 +4651,23 @@ define half @v_rsq_f16_missing_contract0(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -4859,21 +4702,20 @@ define half @v_rsq_f16_missing_contract1(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -4881,24 +4723,23 @@ define half @v_rsq_f16_missing_contract1(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -4933,21 +4774,20 @@ define half @v_neg_rsq_f16_missing_contract0(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -4955,24 +4795,23 @@ define half @v_neg_rsq_f16_missing_contract0(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5007,21 +4846,20 @@ define half @v_neg_rsq_f16_missing_contract1(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -5029,24 +4867,23 @@ define half @v_neg_rsq_f16_missing_contract1(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5081,21 +4918,20 @@ define half @v_neg_rsq_f16_fabs(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e64 v0, |v0| -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -5103,24 +4939,23 @@ define half @v_neg_rsq_f16_fabs(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e64 v0, |v0| -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5156,21 +4991,20 @@ define half @v_rsq_f16_arcp(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -5178,24 +5012,23 @@ define half @v_rsq_f16_arcp(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5220,21 +5053,20 @@ define half @v_neg_rsq_f16_arcp(half %a) { ; GFX6-IEEE: ; %bb.0: ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v5, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-IEEE-NEXT: v_fma_f32 v1, -v1, v4, v3 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] ; @@ -5242,24 +5074,23 @@ define half @v_neg_rsq_f16_arcp(half %a) { ; GFX6-FLUSH: ; %bb.0: ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, v1 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, v1, v0, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v2, v1 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, v4, v2, v2 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v4, v3, v2 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v1, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v4, v5, v2, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v1, -v1, v4, v3 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, v1 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v1, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5294,12 +5125,10 @@ define half @v_rsq_f16_afn(half %a) { ; GFX6: ; %bb.0: ; GFX6-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-NEXT: v_rcp_f32_e32 v0, v0 -; GFX6-NEXT: v_mul_f32_e32 v0, v1, v0 ; GFX6-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-NEXT: s_setpc_b64 s[30:31] ; @@ -5324,12 +5153,10 @@ define half @v_rsq_f16_afn_nocontract(half %a) { ; GFX6: ; %bb.0: ; GFX6-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GFX6-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-NEXT: v_rcp_f32_e32 v0, v0 -; GFX6-NEXT: v_mul_f32_e32 v0, v1, v0 ; GFX6-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-NEXT: s_setpc_b64 s[30:31] ; @@ -5365,36 +5192,35 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, s[4:5], v1, v1, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v9, -v3, v6, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v9, v6, v6 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v8, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v10, -v3, v9, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v9, v10, v6, v9 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v9, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v6, v9 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v5, v8, 1.0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v7, s[4:5], v2, v1, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v3, v8, v8 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v7, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v5, v4, v7 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v3, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v5, v4, v7 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v5, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, s[4:5], v1, v1, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v8, -v2, v5, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v8, v5, v5 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v6, v4 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v8, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v10, -v2, v8, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v8, v10, v5, v8 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v8, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v9, -v4, v6, 1.0 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v5, v8 +; GFX6-IEEE-NEXT: v_div_scale_f32 v7, s[4:5], 1.0, v1, 1.0 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v9, v6, v6 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v3, v7, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v4, v3, v7 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v2, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v4, v3, v7 ; GFX6-IEEE-NEXT: s_mov_b64 vcc, s[4:5] -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v5, v3, v4 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v4, v2, v3 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] @@ -5404,42 +5230,40 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, 1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v0, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, 1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, 1.0, v1, 1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, 1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5448,31 +5272,28 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX8-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-IEEE-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v0 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v10, v10, v4 -; GFX8-IEEE-NEXT: v_add_f32_e32 v9, v9, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v10, v10, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v9, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v2, v2, v5 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v6, -v2, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v7, -v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, 1.0, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, 1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, 1.0, v3 +; GFX8-IEEE-NEXT: v_add_f32_e32 v2, 1.0, v2 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX8-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 -; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v3, v0, 1.0 @@ -5486,25 +5307,22 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-FLUSH-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v2 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v8, v4, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v5 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, -v2, v4, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, 1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v3, v0, 1.0 @@ -5518,25 +5336,22 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX9-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-IEEE-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v0 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v4, v6 -; GFX9-IEEE-NEXT: v_fma_f32 v9, -v2, v7, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v10, -v3, v8, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v7, v9, v5, v7 -; GFX9-IEEE-NEXT: v_fma_f32 v8, v10, v6, v8 -; GFX9-IEEE-NEXT: v_fma_f32 v2, -v2, v7, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v3, -v3, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v2, v2, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_fma_f32 v6, -v2, v4, 1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v7, -v3, v5, 1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v6, v6, v4, v4 +; GFX9-IEEE-NEXT: v_fma_f32 v7, v7, v5, v5 +; GFX9-IEEE-NEXT: v_fma_f32 v2, -v2, v6, 1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v3, -v3, v7, 1.0 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX9-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v1, v2, v1, 1.0 @@ -5549,25 +5364,23 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-FLUSH-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v3, v3 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v5, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v4, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v6, v2 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v4, v7, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v5, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v4, 1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v6, v2 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v7, v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, -v1, v2, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v0, v3, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v5, v5, v2, v2 +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v3, v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v1, v5, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v4, -v0, v6, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v7, v2 +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX9-FLUSH-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v1, v2, v1, 1.0 @@ -5580,25 +5393,23 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX10-IEEE-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX10-IEEE-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v0 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v3, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v1, v5, 1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v0, v4, 1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX10-IEEE-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v1, v5, 1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v0, v4, 1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v6, v2 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v7, v3 +; GFX10-IEEE-NEXT: v_fma_mix_f32 v5, -v1, v2, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v0, v3, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_f32 v5, v5, v2, v2 +; GFX10-IEEE-NEXT: v_fma_f32 v6, v6, v3, v3 +; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v1, v5, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_mix_f32 v4, -v0, v6, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v7, v2 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v1, v2, v1, 1.0 @@ -5611,25 +5422,22 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX10-FLUSH-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, 1.0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, -v2, v4, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, -v3, v5, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, 1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, 1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v1, v2, v1, 1.0 @@ -5642,7 +5450,7 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX11-NEXT: v_sqrt_f16_e32 v0, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v4, 1.0 +; GFX11-NEXT: v_mov_b32_e32 v4, 1.0 ; GFX11-NEXT: v_sqrt_f16_e32 v1, v1 ; GFX11-NEXT: s_waitcnt_depctr 0xfff ; GFX11-NEXT: v_cvt_f32_f16_e32 v2, v0 @@ -5650,22 +5458,20 @@ define <2 x half> @v_rsq_v2f16(<2 x half> %a) { ; GFX11-NEXT: v_rcp_f32_e32 v2, v2 ; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX11-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v4, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v4, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX11-NEXT: v_mul_f32_e32 v3, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, 1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v2, v6, v2 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_dual_add_f32 v3, v3, v4 :: v_dual_and_b32 v2, 0xff800000, v2 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 -; GFX11-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 +; GFX11-NEXT: v_fma_mix_f32 v5, -v0, v2, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v6, -v1, v3, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v5, v5, v2, v2 +; GFX11-NEXT: v_fma_f32 v6, v6, v3, v3 +; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v4, -v1, v6, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_dual_mul_f32 v2, v7, v2 :: v_dual_mul_f32 v3, v4, v3 +; GFX11-NEXT: v_and_b32_e32 v2, 0xff800000, v2 +; GFX11-NEXT: v_dual_add_f32 v2, v2, v5 :: v_dual_and_b32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX11-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v2, v0, 1.0 +; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, 1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v0, v1 ; GFX11-NEXT: s_setpc_b64 s[30:31] %sqrt = call contract <2 x half> @llvm.sqrt.v2f16(<2 x half> %a) @@ -5679,36 +5485,35 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX6-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v2, -1.0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_sqrt_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-IEEE-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX6-IEEE-NEXT: v_div_scale_f32 v4, vcc, v2, v0, v2 -; GFX6-IEEE-NEXT: v_div_scale_f32 v5, s[4:5], v1, v1, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v9, -v3, v6, 1.0 -; GFX6-IEEE-NEXT: v_fma_f32 v6, v9, v6, v6 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v9, v4, v6 -; GFX6-IEEE-NEXT: v_rcp_f32_e32 v8, v5 -; GFX6-IEEE-NEXT: v_fma_f32 v10, -v3, v9, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v9, v10, v6, v9 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v3, v9, v4 -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v3, v6, v9 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v3, v0, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v3, -v5, v8, 1.0 -; GFX6-IEEE-NEXT: v_div_scale_f32 v7, s[4:5], v2, v1, v2 -; GFX6-IEEE-NEXT: v_fma_f32 v3, v3, v8, v8 -; GFX6-IEEE-NEXT: v_mul_f32_e32 v4, v7, v3 -; GFX6-IEEE-NEXT: v_fma_f32 v6, -v5, v4, v7 -; GFX6-IEEE-NEXT: v_fma_f32 v4, v6, v3, v4 -; GFX6-IEEE-NEXT: v_fma_f32 v5, -v5, v4, v7 +; GFX6-IEEE-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, -1.0 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v5, v2 +; GFX6-IEEE-NEXT: v_div_scale_f32 v3, vcc, -1.0, v0, -1.0 +; GFX6-IEEE-NEXT: v_div_scale_f32 v4, s[4:5], v1, v1, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v8, -v2, v5, 1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v5, v8, v5, v5 +; GFX6-IEEE-NEXT: v_rcp_f32_e32 v6, v4 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v8, v3, v5 +; GFX6-IEEE-NEXT: v_fma_f32 v10, -v2, v8, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v8, v10, v5, v8 +; GFX6-IEEE-NEXT: v_fma_f32 v2, -v2, v8, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v9, -v4, v6, 1.0 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v2, v5, v8 +; GFX6-IEEE-NEXT: v_div_scale_f32 v7, s[4:5], -1.0, v1, -1.0 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v0, v2, v0, -1.0 +; GFX6-IEEE-NEXT: v_fma_f32 v2, v9, v6, v6 +; GFX6-IEEE-NEXT: v_mul_f32_e32 v3, v7, v2 +; GFX6-IEEE-NEXT: v_fma_f32 v5, -v4, v3, v7 +; GFX6-IEEE-NEXT: v_fma_f32 v3, v5, v2, v3 +; GFX6-IEEE-NEXT: v_fma_f32 v4, -v4, v3, v7 ; GFX6-IEEE-NEXT: s_mov_b64 vcc, s[4:5] -; GFX6-IEEE-NEXT: v_div_fmas_f32 v3, v5, v3, v4 -; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v3, v1, v2 +; GFX6-IEEE-NEXT: v_div_fmas_f32 v2, v4, v2, v3 +; GFX6-IEEE-NEXT: v_div_fixup_f32 v1, v2, v1, -1.0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-IEEE-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-IEEE-NEXT: s_setpc_b64 s[30:31] @@ -5718,42 +5523,40 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX6-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, -1.0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_sqrt_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 2, 2), 0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v3, s[4:5], v0, v0, v2 -; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v4, v3 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v2, v0, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v0, v0, -1.0 +; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v0, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v3, v4, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v4, v6, v4, v4 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v4 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v3, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v4, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, -v3, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v3, v3, v4, v6 -; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v3, v0, v2 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v0, v2, v0, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v2, s[4:5], v1, v1, -1.0 ; GFX6-FLUSH-NEXT: v_rcp_f32_e32 v3, v2 -; GFX6-FLUSH-NEXT: v_div_scale_f32 v5, vcc, v4, v1, v4 +; GFX6-FLUSH-NEXT: v_div_scale_f32 v4, vcc, -1.0, v1, -1.0 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v3, 1.0 -; GFX6-FLUSH-NEXT: v_fma_f32 v3, v6, v3, v3 -; GFX6-FLUSH-NEXT: v_mul_f32_e32 v6, v5, v3 -; GFX6-FLUSH-NEXT: v_fma_f32 v7, -v2, v6, v5 -; GFX6-FLUSH-NEXT: v_fma_f32 v6, v7, v3, v6 -; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v6, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, -v2, v3, 1.0 +; GFX6-FLUSH-NEXT: v_fma_f32 v3, v5, v3, v3 +; GFX6-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v3 +; GFX6-FLUSH-NEXT: v_fma_f32 v6, -v2, v5, v4 +; GFX6-FLUSH-NEXT: v_fma_f32 v5, v6, v3, v5 +; GFX6-FLUSH-NEXT: v_fma_f32 v2, -v2, v5, v4 ; GFX6-FLUSH-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v6 -; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, v4 +; GFX6-FLUSH-NEXT: v_div_fmas_f32 v2, v2, v3, v5 +; GFX6-FLUSH-NEXT: v_div_fixup_f32 v1, v2, v1, -1.0 ; GFX6-FLUSH-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GFX6-FLUSH-NEXT: s_setpc_b64 s[30:31] ; @@ -5762,31 +5565,28 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX8-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-IEEE-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX8-IEEE-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX8-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v0 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v2 -; GFX8-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v8, v4, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v10, -v3, v8 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v9, -v2, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v10, v10, v4 -; GFX8-IEEE-NEXT: v_add_f32_e32 v9, v9, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v10, v10, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v9, v9, v5 -; GFX8-IEEE-NEXT: v_add_f32_e32 v8, v10, v8 -; GFX8-IEEE-NEXT: v_add_f32_e32 v7, v9, v7 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v8 -; GFX8-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v7 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 -; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v4 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 -; GFX8-IEEE-NEXT: v_mul_f32_e32 v2, v2, v5 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX8-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v2, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v3, v5 +; GFX8-IEEE-NEXT: v_add_f32_e32 v7, -1.0, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v6, -1.0, v6 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v7, v7, v5 +; GFX8-IEEE-NEXT: v_sub_f32_e32 v6, v6, v4 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v3, -v3, v7 +; GFX8-IEEE-NEXT: v_mul_f32_e64 v2, -v2, v6 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, -1.0, v3 +; GFX8-IEEE-NEXT: v_add_f32_e32 v2, -1.0, v2 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 +; GFX8-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX8-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX8-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 -; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 -; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 +; GFX8-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX8-IEEE-NEXT: v_div_fixup_f16 v0, v3, v0, -1.0 @@ -5800,25 +5600,22 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX8-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX8-FLUSH-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX8-FLUSH-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX8-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v2 -; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v6, v3 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v8, v4, v6 -; GFX8-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v4 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v6 -; GFX8-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v5 -; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v4 -; GFX8-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v4 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v6 -; GFX8-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v5 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 +; GFX8-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v2, v4, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX8-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX8-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 +; GFX8-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, -1.0 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 +; GFX8-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX8-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 -; GFX8-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 +; GFX8-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX8-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX8-FLUSH-NEXT: v_div_fixup_f16 v0, v3, v0, -1.0 @@ -5832,25 +5629,22 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX9-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-IEEE-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX9-IEEE-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v0 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v2 -; GFX9-IEEE-NEXT: v_rcp_f32_e32 v6, v3 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v7, v4, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v8, v4, v6 -; GFX9-IEEE-NEXT: v_fma_f32 v9, -v2, v7, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v10, -v3, v8, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v7, v9, v5, v7 -; GFX9-IEEE-NEXT: v_fma_f32 v8, v10, v6, v8 -; GFX9-IEEE-NEXT: v_fma_f32 v2, -v2, v7, v4 -; GFX9-IEEE-NEXT: v_fma_f32 v3, -v3, v8, v4 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v2, v2, v5 -; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v6 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v4, v2 +; GFX9-IEEE-NEXT: v_rcp_f32_e32 v5, v3 +; GFX9-IEEE-NEXT: v_fma_f32 v6, v2, v4, -1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v7, v3, v5, -1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v6, v6, v4, -v4 +; GFX9-IEEE-NEXT: v_fma_f32 v7, v7, v5, -v5 +; GFX9-IEEE-NEXT: v_fma_f32 v2, -v2, v6, -1.0 +; GFX9-IEEE-NEXT: v_fma_f32 v3, -v3, v7, -1.0 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v2, v2, v4 +; GFX9-IEEE-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX9-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX9-IEEE-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX9-IEEE-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX9-IEEE-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-IEEE-NEXT: v_div_fixup_f16 v1, v2, v1, -1.0 @@ -5863,25 +5657,23 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX9-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-FLUSH-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX9-FLUSH-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX9-FLUSH-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX9-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_rcp_f32_e32 v3, v3 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v5, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v4, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v5, v6, v2 -; GFX9-FLUSH-NEXT: v_mac_f32_e32 v4, v7, v3 -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, -v1, v5, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v0, v4, -1.0 op_sel_hi:[1,0,1] -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v6, v2 -; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v7, v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v5, v1, v2, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v6, v0, v3, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_f32 v5, v5, v2, -v2 +; GFX9-FLUSH-NEXT: v_mad_f32 v6, v6, v3, -v3 +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v7, -v1, v5, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mad_mix_f32 v4, -v0, v6, v4 op_sel_hi:[1,0,0] +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v2, v7, v2 +; GFX9-FLUSH-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX9-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX9-FLUSH-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX9-FLUSH-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX9-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX9-FLUSH-NEXT: v_div_fixup_f16 v1, v2, v1, -1.0 @@ -5894,25 +5686,23 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX10-IEEE-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-IEEE-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX10-IEEE-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX10-IEEE-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX10-IEEE-NEXT: v_cvt_f32_f16_e32 v3, v0 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_rcp_f32_e32 v3, v3 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v1, v5, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v0, v4, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX10-IEEE-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, -v1, v5, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v0, v4, -1.0 op_sel_hi:[1,0,1] -; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v6, v2 -; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v7, v3 +; GFX10-IEEE-NEXT: v_fma_mix_f32 v5, v1, v2, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_mix_f32 v6, v0, v3, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_f32 v5, v5, v2, -v2 +; GFX10-IEEE-NEXT: v_fma_f32 v6, v6, v3, -v3 +; GFX10-IEEE-NEXT: v_fma_mix_f32 v7, -v1, v5, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_fma_mix_f32 v4, -v0, v6, v4 op_sel_hi:[1,0,0] +; GFX10-IEEE-NEXT: v_mul_f32_e32 v2, v7, v2 +; GFX10-IEEE-NEXT: v_mul_f32_e32 v3, v4, v3 ; GFX10-IEEE-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-IEEE-NEXT: v_and_b32_e32 v3, 0xff800000, v3 ; GFX10-IEEE-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v4 +; GFX10-IEEE-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-IEEE-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-IEEE-NEXT: v_div_fixup_f16 v1, v2, v1, -1.0 @@ -5925,25 +5715,22 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX10-FLUSH-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-FLUSH-NEXT: v_sqrt_f16_e32 v1, v0 ; GFX10-FLUSH-NEXT: v_sqrt_f16_sdwa v0, v0 dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_1 -; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v6, -1.0 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v2, v1 ; GFX10-FLUSH-NEXT: v_cvt_f32_f16_e32 v3, v0 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v4, v2 ; GFX10-FLUSH-NEXT: v_rcp_f32_e32 v5, v3 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v7, v6, v4 -; GFX10-FLUSH-NEXT: v_mul_f32_e32 v8, v6, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v9, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v10, -v3, v8, v6 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v7, v9, v4 -; GFX10-FLUSH-NEXT: v_mac_f32_e32 v8, v10, v5 -; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v7, v6 -; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v8, v6 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v2, v4, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v3, v5, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v6, v6, v4, -v4 +; GFX10-FLUSH-NEXT: v_mad_f32 v7, v7, v5, -v5 +; GFX10-FLUSH-NEXT: v_mad_f32 v2, -v2, v6, -1.0 +; GFX10-FLUSH-NEXT: v_mad_f32 v3, -v3, v7, -1.0 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v2, v2, v4 ; GFX10-FLUSH-NEXT: v_mul_f32_e32 v3, v3, v5 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v2, 0xff800000, v2 ; GFX10-FLUSH-NEXT: v_and_b32_e32 v3, 0xff800000, v3 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v7 -; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v8 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v2, v2, v6 +; GFX10-FLUSH-NEXT: v_add_f32_e32 v3, v3, v7 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GFX10-FLUSH-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX10-FLUSH-NEXT: v_div_fixup_f16 v1, v2, v1, -1.0 @@ -5956,7 +5743,7 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX11-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GFX11-NEXT: v_sqrt_f16_e32 v0, v0 -; GFX11-NEXT: v_cvt_f32_f16_e32 v4, -1.0 +; GFX11-NEXT: v_mov_b32_e32 v4, -1.0 ; GFX11-NEXT: v_sqrt_f16_e32 v1, v1 ; GFX11-NEXT: s_waitcnt_depctr 0xfff ; GFX11-NEXT: v_cvt_f32_f16_e32 v2, v0 @@ -5964,22 +5751,20 @@ define <2 x half> @v_neg_rsq_v2f16(<2 x half> %a) { ; GFX11-NEXT: v_rcp_f32_e32 v2, v2 ; GFX11-NEXT: v_rcp_f32_e32 v3, v3 ; GFX11-NEXT: s_waitcnt_depctr 0xfff -; GFX11-NEXT: v_mul_f32_e32 v5, v4, v2 -; GFX11-NEXT: v_mul_f32_e32 v4, v4, v3 -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v4, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fma_mix_f32 v7, -v1, v4, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_fmac_f32_e32 v5, v6, v2 -; GFX11-NEXT: v_mul_f32_e32 v3, v7, v3 -; GFX11-NEXT: v_fma_mix_f32 v6, -v0, v5, -1.0 op_sel_hi:[1,0,1] -; GFX11-NEXT: v_dual_mul_f32 v2, v6, v2 :: v_dual_and_b32 v3, 0xff800000, v3 -; GFX11-NEXT: v_dual_add_f32 v3, v3, v4 :: v_dual_and_b32 v2, 0xff800000, v2 -; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 -; GFX11-NEXT: v_add_f32_e32 v2, v2, v5 -; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 +; GFX11-NEXT: v_fma_mix_f32 v5, v0, v2, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v6, v1, v3, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_f32 v5, v5, v2, -v2 +; GFX11-NEXT: v_fma_f32 v6, v6, v3, -v3 +; GFX11-NEXT: v_fma_mix_f32 v7, -v0, v5, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_fma_mix_f32 v4, -v1, v6, v4 op_sel_hi:[1,0,0] +; GFX11-NEXT: v_dual_mul_f32 v2, v7, v2 :: v_dual_mul_f32 v3, v4, v3 +; GFX11-NEXT: v_and_b32_e32 v2, 0xff800000, v2 +; GFX11-NEXT: v_dual_add_f32 v2, v2, v5 :: v_dual_and_b32 v3, 0xff800000, v3 +; GFX11-NEXT: v_add_f32_e32 v3, v3, v6 ; GFX11-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GFX11-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GFX11-NEXT: v_div_fixup_f16 v0, v2, v0, -1.0 +; GFX11-NEXT: v_div_fixup_f16 v1, v3, v1, -1.0 ; GFX11-NEXT: v_pack_b32_f16 v0, v0, v1 ; GFX11-NEXT: s_setpc_b64 s[30:31] %sqrt = call contract <2 x half> @llvm.sqrt.v2f16(<2 x half> %a) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/frem.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/frem.ll index 302b239..549af87 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/frem.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/frem.ll @@ -88,11 +88,10 @@ define amdgpu_kernel void @frem_f16(ptr addrspace(1) %out, ptr addrspace(1) %in1 ; CI-NEXT: v_or_b32_e32 v1, s4, v0 ; CI-NEXT: .LBB0_8: ; %Flow19 ; CI-NEXT: v_cvt_f32_f16_e32 v0, s3 -; CI-NEXT: v_cvt_f32_f16_e32 v2, 0 ; CI-NEXT: s_and_b32 s2, s2, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s2, 0x7c00 ; CI-NEXT: s_cselect_b32 s2, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e32 vcc, v0, v2 +; CI-NEXT: v_cmp_nlg_f32_e32 vcc, 0, v0 ; CI-NEXT: v_mov_b32_e32 v0, 0x7e00 ; CI-NEXT: s_and_b32 s2, 1, s2 ; CI-NEXT: v_cndmask_b32_e32 v1, v1, v0, vcc @@ -1197,16 +1196,15 @@ define amdgpu_kernel void @frem_v2f16(ptr addrspace(1) %out, ptr addrspace(1) %i ; CI-NEXT: v_or_b32_e32 v1, s4, v1 ; CI-NEXT: .LBB9_16: ; %Flow54 ; CI-NEXT: v_cvt_f32_f16_e32 v2, s1 -; CI-NEXT: v_cvt_f32_f16_e32 v3, 0 ; CI-NEXT: s_and_b32 s0, s0, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s0, 0x7c00 ; CI-NEXT: s_cselect_b32 s4, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e32 vcc, v2, v3 +; CI-NEXT: v_cmp_nlg_f32_e32 vcc, 0, v2 ; CI-NEXT: v_cvt_f32_f16_e32 v2, s3 ; CI-NEXT: s_and_b32 s2, s2, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s2, 0x7c00 ; CI-NEXT: s_cselect_b32 s2, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e64 s[0:1], v2, v3 +; CI-NEXT: v_cmp_nlg_f32_e64 s[0:1], 0, v2 ; CI-NEXT: v_and_b32_e32 v0, 0xffff, v0 ; CI-NEXT: v_mov_b32_e32 v2, 0x7e00 ; CI-NEXT: s_and_b32 s3, 1, s4 @@ -1730,26 +1728,25 @@ define amdgpu_kernel void @frem_v4f16(ptr addrspace(1) %out, ptr addrspace(1) %i ; CI-NEXT: v_or_b32_e32 v3, s1, v3 ; CI-NEXT: .LBB10_32: ; %Flow124 ; CI-NEXT: v_cvt_f32_f16_e32 v4, s2 -; CI-NEXT: v_cvt_f32_f16_e32 v5, 0 ; CI-NEXT: s_and_b32 s1, s4, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s1, 0x7c00 ; CI-NEXT: s_cselect_b32 s11, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e32 vcc, v4, v5 +; CI-NEXT: v_cmp_nlg_f32_e32 vcc, 0, v4 ; CI-NEXT: v_cvt_f32_f16_e32 v4, s0 ; CI-NEXT: s_and_b32 s2, s6, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s2, 0x7c00 ; CI-NEXT: s_cselect_b32 s6, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e64 s[0:1], v4, v5 +; CI-NEXT: v_cmp_nlg_f32_e64 s[0:1], 0, v4 ; CI-NEXT: v_cvt_f32_f16_e32 v4, s3 ; CI-NEXT: s_and_b32 s4, s5, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s4, 0x7c00 ; CI-NEXT: s_cselect_b32 s12, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e64 s[2:3], v4, v5 +; CI-NEXT: v_cmp_nlg_f32_e64 s[2:3], 0, v4 ; CI-NEXT: v_cvt_f32_f16_e32 v4, s10 ; CI-NEXT: s_and_b32 s7, s7, 0x7fff ; CI-NEXT: s_cmpk_lg_i32 s7, 0x7c00 ; CI-NEXT: s_cselect_b32 s7, 1, 0 -; CI-NEXT: v_cmp_nlg_f32_e64 s[4:5], v4, v5 +; CI-NEXT: v_cmp_nlg_f32_e64 s[4:5], 0, v4 ; CI-NEXT: v_and_b32_e32 v0, 0xffff, v0 ; CI-NEXT: v_mov_b32_e32 v4, 0x7e00 ; CI-NEXT: s_and_b32 s10, 1, s11 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smax.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smax.mir index eee553e..a7023d0 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smax.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smax.mir @@ -1,6 +1,5 @@ # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-fast -o - %s | FileCheck %s -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-greedy -o - %s | FileCheck %s +# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass='amdgpu-regbankselect,amdgpu-regbanklegalize' -o - %s | FileCheck %s --- name: smax_s32_ss @@ -188,8 +187,7 @@ body: | ; CHECK-NEXT: [[ASHR:%[0-9]+]]:sgpr(s32) = G_ASHR [[BITCAST]], [[C]](s32) ; CHECK-NEXT: [[BITCAST1:%[0-9]+]]:sgpr(s32) = G_BITCAST [[COPY1]](<2 x s16>) ; CHECK-NEXT: [[SEXT_INREG1:%[0-9]+]]:sgpr(s32) = G_SEXT_INREG [[BITCAST1]], 16 - ; CHECK-NEXT: [[C1:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 - ; CHECK-NEXT: [[ASHR1:%[0-9]+]]:sgpr(s32) = G_ASHR [[BITCAST1]], [[C1]](s32) + ; CHECK-NEXT: [[ASHR1:%[0-9]+]]:sgpr(s32) = G_ASHR [[BITCAST1]], [[C]](s32) ; CHECK-NEXT: [[SMAX:%[0-9]+]]:sgpr(s32) = G_SMAX [[SEXT_INREG]], [[SEXT_INREG1]] ; CHECK-NEXT: [[SMAX1:%[0-9]+]]:sgpr(s32) = G_SMAX [[ASHR]], [[ASHR1]] ; CHECK-NEXT: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:sgpr(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[SMAX]](s32), [[SMAX1]](s32) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smin.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smin.mir index ef60aa8..9dd5f45 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smin.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-smin.mir @@ -1,6 +1,5 @@ # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-fast -o - %s | FileCheck %s -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-greedy -o - %s | FileCheck %s +# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass='amdgpu-regbankselect,amdgpu-regbanklegalize' -o - %s | FileCheck %s --- name: smin_s32_ss @@ -191,8 +190,7 @@ body: | ; CHECK-NEXT: [[ASHR:%[0-9]+]]:sgpr(s32) = G_ASHR [[BITCAST]], [[C]](s32) ; CHECK-NEXT: [[BITCAST1:%[0-9]+]]:sgpr(s32) = G_BITCAST [[COPY1]](<2 x s16>) ; CHECK-NEXT: [[SEXT_INREG1:%[0-9]+]]:sgpr(s32) = G_SEXT_INREG [[BITCAST1]], 16 - ; CHECK-NEXT: [[C1:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 - ; CHECK-NEXT: [[ASHR1:%[0-9]+]]:sgpr(s32) = G_ASHR [[BITCAST1]], [[C1]](s32) + ; CHECK-NEXT: [[ASHR1:%[0-9]+]]:sgpr(s32) = G_ASHR [[BITCAST1]], [[C]](s32) ; CHECK-NEXT: [[SMIN:%[0-9]+]]:sgpr(s32) = G_SMIN [[SEXT_INREG]], [[SEXT_INREG1]] ; CHECK-NEXT: [[SMIN1:%[0-9]+]]:sgpr(s32) = G_SMIN [[ASHR]], [[ASHR1]] ; CHECK-NEXT: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:sgpr(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[SMIN]](s32), [[SMIN1]](s32) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umax.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umax.mir index 36a38aa..59d7dce 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umax.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umax.mir @@ -1,6 +1,5 @@ # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-fast -o - %s | FileCheck %s -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-greedy -o - %s | FileCheck %s +# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass='amdgpu-regbankselect,amdgpu-regbanklegalize' -o - %s | FileCheck %s --- name: umax_s32_ss @@ -186,15 +185,13 @@ body: | ; CHECK-NEXT: [[COPY:%[0-9]+]]:sgpr(<2 x s16>) = COPY $sgpr0 ; CHECK-NEXT: [[COPY1:%[0-9]+]]:sgpr(<2 x s16>) = COPY $sgpr1 ; CHECK-NEXT: [[BITCAST:%[0-9]+]]:sgpr(s32) = G_BITCAST [[COPY]](<2 x s16>) - ; CHECK-NEXT: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 - ; CHECK-NEXT: [[LSHR:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST]], [[C]](s32) - ; CHECK-NEXT: [[C1:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 65535 - ; CHECK-NEXT: [[AND:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST]], [[C1]] + ; CHECK-NEXT: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 65535 + ; CHECK-NEXT: [[AND:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST]], [[C]] + ; CHECK-NEXT: [[C1:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 + ; CHECK-NEXT: [[LSHR:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST]], [[C1]](s32) ; CHECK-NEXT: [[BITCAST1:%[0-9]+]]:sgpr(s32) = G_BITCAST [[COPY1]](<2 x s16>) - ; CHECK-NEXT: [[C2:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 - ; CHECK-NEXT: [[LSHR1:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST1]], [[C2]](s32) - ; CHECK-NEXT: [[C3:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 65535 - ; CHECK-NEXT: [[AND1:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST1]], [[C3]] + ; CHECK-NEXT: [[AND1:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST1]], [[C]] + ; CHECK-NEXT: [[LSHR1:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST1]], [[C1]](s32) ; CHECK-NEXT: [[UMAX:%[0-9]+]]:sgpr(s32) = G_UMAX [[AND]], [[AND1]] ; CHECK-NEXT: [[UMAX1:%[0-9]+]]:sgpr(s32) = G_UMAX [[LSHR]], [[LSHR1]] ; CHECK-NEXT: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:sgpr(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[UMAX]](s32), [[UMAX1]](s32) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umin.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umin.mir index bb232b5e..fdb05f6 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umin.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-umin.mir @@ -1,6 +1,5 @@ # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-fast -o - %s | FileCheck %s -# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass=regbankselect -verify-machineinstrs -regbankselect-greedy -o - %s | FileCheck %s +# RUN: llc -mtriple=amdgcn -mcpu=gfx900 -run-pass='amdgpu-regbankselect,amdgpu-regbanklegalize' -o - %s | FileCheck %s --- name: umin_s32_ss @@ -190,15 +189,13 @@ body: | ; CHECK-NEXT: [[COPY:%[0-9]+]]:sgpr(<2 x s16>) = COPY $sgpr0 ; CHECK-NEXT: [[COPY1:%[0-9]+]]:sgpr(<2 x s16>) = COPY $sgpr1 ; CHECK-NEXT: [[BITCAST:%[0-9]+]]:sgpr(s32) = G_BITCAST [[COPY]](<2 x s16>) - ; CHECK-NEXT: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 - ; CHECK-NEXT: [[LSHR:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST]], [[C]](s32) - ; CHECK-NEXT: [[C1:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 65535 - ; CHECK-NEXT: [[AND:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST]], [[C1]] + ; CHECK-NEXT: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 65535 + ; CHECK-NEXT: [[AND:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST]], [[C]] + ; CHECK-NEXT: [[C1:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 + ; CHECK-NEXT: [[LSHR:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST]], [[C1]](s32) ; CHECK-NEXT: [[BITCAST1:%[0-9]+]]:sgpr(s32) = G_BITCAST [[COPY1]](<2 x s16>) - ; CHECK-NEXT: [[C2:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 16 - ; CHECK-NEXT: [[LSHR1:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST1]], [[C2]](s32) - ; CHECK-NEXT: [[C3:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 65535 - ; CHECK-NEXT: [[AND1:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST1]], [[C3]] + ; CHECK-NEXT: [[AND1:%[0-9]+]]:sgpr(s32) = G_AND [[BITCAST1]], [[C]] + ; CHECK-NEXT: [[LSHR1:%[0-9]+]]:sgpr(s32) = G_LSHR [[BITCAST1]], [[C1]](s32) ; CHECK-NEXT: [[UMIN:%[0-9]+]]:sgpr(s32) = G_UMIN [[AND]], [[AND1]] ; CHECK-NEXT: [[UMIN1:%[0-9]+]]:sgpr(s32) = G_UMIN [[LSHR]], [[LSHR1]] ; CHECK-NEXT: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:sgpr(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[UMIN]](s32), [[UMIN1]](s32) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/sdiv.i64.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/sdiv.i64.ll index 9ffc565..4f2c454 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/sdiv.i64.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/sdiv.i64.ll @@ -2537,202 +2537,195 @@ define <2 x i64> @v_sdiv_v2i64_24bit(<2 x i64> %num, <2 x i64> %den) { ; GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GISEL-NEXT: v_and_b32_e32 v1, 0xffffff, v4 ; GISEL-NEXT: v_cvt_f32_u32_e32 v3, v1 -; GISEL-NEXT: v_cvt_f32_ubyte0_e32 v5, 0 -; GISEL-NEXT: v_sub_i32_e32 v10, vcc, 0, v1 -; GISEL-NEXT: v_mac_f32_e32 v3, 0x4f800000, v5 +; GISEL-NEXT: v_cvt_f32_ubyte0_e32 v9, 0 +; GISEL-NEXT: v_sub_i32_e32 v8, vcc, 0, v1 +; GISEL-NEXT: v_mac_f32_e32 v3, 0x4f800000, v9 ; GISEL-NEXT: v_rcp_iflag_f32_e32 v3, v3 -; GISEL-NEXT: v_subb_u32_e64 v11, s[4:5], 0, 0, vcc +; GISEL-NEXT: v_subb_u32_e64 v10, s[4:5], 0, 0, vcc ; GISEL-NEXT: v_mul_f32_e32 v3, 0x5f7ffffc, v3 ; GISEL-NEXT: v_mul_f32_e32 v4, 0x2f800000, v3 -; GISEL-NEXT: v_trunc_f32_e32 v7, v4 -; GISEL-NEXT: v_mac_f32_e32 v3, 0xcf800000, v7 -; GISEL-NEXT: v_cvt_u32_f32_e32 v9, v3 -; GISEL-NEXT: v_cvt_u32_f32_e32 v12, v7 -; GISEL-NEXT: v_mad_u64_u32 v[3:4], s[4:5], v10, v9, 0 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v10, v12, v[4:5] -; GISEL-NEXT: v_mul_lo_u32 v4, v12, v3 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v11, v9, v[7:8] -; GISEL-NEXT: v_mul_hi_u32 v8, v9, v3 -; GISEL-NEXT: v_mul_hi_u32 v3, v12, v3 -; GISEL-NEXT: v_mul_lo_u32 v13, v9, v7 -; GISEL-NEXT: v_mul_lo_u32 v14, v12, v7 -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v13 +; GISEL-NEXT: v_trunc_f32_e32 v5, v4 +; GISEL-NEXT: v_mac_f32_e32 v3, 0xcf800000, v5 +; GISEL-NEXT: v_cvt_u32_f32_e32 v7, v3 +; GISEL-NEXT: v_cvt_u32_f32_e32 v11, v5 +; GISEL-NEXT: v_mad_u64_u32 v[3:4], s[4:5], v8, v7, 0 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v8, v11, v[4:5] +; GISEL-NEXT: v_mul_hi_u32 v12, v7, v3 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v10, v7, v[4:5] +; GISEL-NEXT: v_mul_lo_u32 v5, v11, v3 +; GISEL-NEXT: v_mul_hi_u32 v3, v11, v3 +; GISEL-NEXT: v_mul_lo_u32 v13, v7, v4 +; GISEL-NEXT: v_mul_lo_u32 v14, v11, v4 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v13 ; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v8 -; GISEL-NEXT: v_mul_hi_u32 v8, v9, v7 -; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v13, v4 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v12 +; GISEL-NEXT: v_mul_hi_u32 v12, v7, v4 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v13, v5 ; GISEL-NEXT: v_add_i32_e32 v3, vcc, v14, v3 ; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v8 -; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v8, vcc, v13, v8 -; GISEL-NEXT: v_mul_hi_u32 v7, v12, v7 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v8, v4 -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v7, v4 -; GISEL-NEXT: v_add_i32_e32 v9, vcc, v9, v3 -; GISEL-NEXT: v_addc_u32_e32 v12, vcc, v12, v4, vcc -; GISEL-NEXT: v_mad_u64_u32 v[3:4], s[4:5], v10, v9, 0 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v10, v12, v[4:5] -; GISEL-NEXT: v_mul_lo_u32 v4, v12, v3 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v12 +; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v12, vcc, v13, v12 +; GISEL-NEXT: v_mul_hi_u32 v4, v11, v4 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v12, v5 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v5 +; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v3 +; GISEL-NEXT: v_addc_u32_e32 v11, vcc, v11, v4, vcc +; GISEL-NEXT: v_mad_u64_u32 v[3:4], s[4:5], v8, v7, 0 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v8, v11, v[4:5] +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v10, v7, v[4:5] +; GISEL-NEXT: v_mul_lo_u32 v5, v11, v3 ; GISEL-NEXT: v_and_b32_e32 v10, 0xffffff, v0 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v11, v9, v[7:8] -; GISEL-NEXT: v_mul_hi_u32 v0, v9, v3 -; GISEL-NEXT: v_mul_hi_u32 v3, v12, v3 -; GISEL-NEXT: v_mul_lo_u32 v8, v9, v7 -; GISEL-NEXT: v_and_b32_e32 v11, 0xffffff, v2 -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v8 +; GISEL-NEXT: v_mul_lo_u32 v8, v7, v4 +; GISEL-NEXT: v_mul_hi_u32 v0, v7, v3 +; GISEL-NEXT: v_mul_hi_u32 v3, v11, v3 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v8 ; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v4, v0 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v5, v0 ; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, 1, vcc -; GISEL-NEXT: v_mul_lo_u32 v4, v12, v7 +; GISEL-NEXT: v_mul_lo_u32 v5, v11, v4 ; GISEL-NEXT: v_add_i32_e32 v0, vcc, v8, v0 -; GISEL-NEXT: v_mul_hi_u32 v8, v9, v7 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v4, v3 -; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc +; GISEL-NEXT: v_mul_hi_u32 v8, v7, v4 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v5, v3 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v8 ; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v8 -; GISEL-NEXT: v_mul_hi_u32 v7, v12, v7 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v8 +; GISEL-NEXT: v_mul_hi_u32 v4, v11, v4 ; GISEL-NEXT: v_add_i32_e32 v0, vcc, v3, v0 ; GISEL-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v5, v3 ; GISEL-NEXT: v_add_i32_e32 v3, vcc, v4, v3 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v7, v3 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v9, v0 -; GISEL-NEXT: v_addc_u32_e32 v4, vcc, v12, v3, vcc -; GISEL-NEXT: v_mul_lo_u32 v7, 0, v0 -; GISEL-NEXT: v_mul_lo_u32 v8, v10, v4 -; GISEL-NEXT: v_and_b32_e32 v3, 0xffffff, v6 -; GISEL-NEXT: v_mul_hi_u32 v6, v10, v0 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v7, v0 +; GISEL-NEXT: v_addc_u32_e32 v3, vcc, v11, v3, vcc +; GISEL-NEXT: v_mul_lo_u32 v4, 0, v0 +; GISEL-NEXT: v_mul_lo_u32 v5, v10, v3 +; GISEL-NEXT: v_mul_hi_u32 v7, v10, v0 ; GISEL-NEXT: v_mul_hi_u32 v0, 0, v0 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v8 -; GISEL-NEXT: v_mul_lo_u32 v8, 0, v4 -; GISEL-NEXT: v_add_i32_e32 v6, vcc, v7, v6 -; GISEL-NEXT: v_mul_hi_u32 v7, v10, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v8, v0 +; GISEL-NEXT: v_and_b32_e32 v11, 0xffffff, v2 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v5 +; GISEL-NEXT: v_mul_lo_u32 v5, 0, v3 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v7 +; GISEL-NEXT: v_mul_hi_u32 v7, v10, v3 +; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v5, v0 ; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v7 -; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v6 -; GISEL-NEXT: v_mul_hi_u32 v4, 0, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v1, v0, 0 -; GISEL-NEXT: v_add_i32_e32 v8, vcc, v8, v9 -; GISEL-NEXT: v_cvt_f32_u32_e32 v9, v3 -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v8 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v1, v4, v[7:8] -; GISEL-NEXT: v_mac_f32_e32 v9, 0x4f800000, v5 -; GISEL-NEXT: v_rcp_iflag_f32_e32 v2, v9 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], 0, v0, v[7:8] -; GISEL-NEXT: v_sub_i32_e32 v8, vcc, v10, v6 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v4 +; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v1, v0, 0 +; GISEL-NEXT: v_mul_hi_u32 v4, 0, v3 +; GISEL-NEXT: v_and_b32_e32 v3, 0xffffff, v6 +; GISEL-NEXT: v_mov_b32_e32 v5, v8 +; GISEL-NEXT: v_cvt_f32_u32_e32 v8, v3 +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v1, v4, v[5:6] +; GISEL-NEXT: v_mac_f32_e32 v8, 0x4f800000, v9 +; GISEL-NEXT: v_rcp_iflag_f32_e32 v2, v8 +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], 0, v0, v[5:6] +; GISEL-NEXT: v_sub_i32_e32 v9, vcc, v10, v7 ; GISEL-NEXT: v_mul_f32_e32 v2, 0x5f7ffffc, v2 -; GISEL-NEXT: v_mul_f32_e32 v5, 0x2f800000, v2 -; GISEL-NEXT: v_subb_u32_e64 v9, s[4:5], 0, v7, vcc -; GISEL-NEXT: v_sub_i32_e64 v10, s[4:5], 0, v7 -; GISEL-NEXT: v_trunc_f32_e32 v7, v5 -; GISEL-NEXT: v_mac_f32_e32 v2, 0xcf800000, v7 +; GISEL-NEXT: v_mul_f32_e32 v6, 0x2f800000, v2 +; GISEL-NEXT: v_trunc_f32_e32 v8, v6 +; GISEL-NEXT: v_mac_f32_e32 v2, 0xcf800000, v8 ; GISEL-NEXT: v_cvt_u32_f32_e32 v12, v2 +; GISEL-NEXT: v_subb_u32_e64 v10, s[4:5], 0, v5, vcc ; GISEL-NEXT: v_sub_i32_e64 v13, s[4:5], 0, v3 ; GISEL-NEXT: v_subb_u32_e64 v14, s[4:5], 0, 0, s[4:5] -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v13, v12, 0 -; GISEL-NEXT: v_cvt_u32_f32_e32 v15, v7 -; GISEL-NEXT: v_cmp_ge_u32_e64 s[4:5], v8, v1 -; GISEL-NEXT: v_mov_b32_e32 v2, v6 -; GISEL-NEXT: v_cndmask_b32_e64 v16, 0, -1, s[4:5] -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v13, v15, v[2:3] -; GISEL-NEXT: v_cmp_eq_u32_e64 s[4:5], 0, v9 -; GISEL-NEXT: v_cndmask_b32_e64 v9, -1, v16, s[4:5] -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v14, v12, v[6:7] -; GISEL-NEXT: v_subbrev_u32_e32 v2, vcc, 0, v10, vcc -; GISEL-NEXT: v_mul_lo_u32 v7, v15, v5 -; GISEL-NEXT: v_mul_lo_u32 v10, v12, v6 -; GISEL-NEXT: v_sub_i32_e32 v8, vcc, v8, v1 -; GISEL-NEXT: v_subbrev_u32_e32 v16, vcc, 0, v2, vcc -; GISEL-NEXT: v_mul_hi_u32 v2, v12, v5 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v10 +; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v13, v12, 0 +; GISEL-NEXT: v_cvt_u32_f32_e32 v15, v8 +; GISEL-NEXT: v_sub_i32_e64 v5, s[4:5], 0, v5 +; GISEL-NEXT: v_mov_b32_e32 v2, v7 +; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v13, v15, v[2:3] +; GISEL-NEXT: v_cmp_ge_u32_e64 s[4:5], v9, v1 +; GISEL-NEXT: v_cndmask_b32_e64 v2, 0, -1, s[4:5] +; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v14, v12, v[7:8] +; GISEL-NEXT: v_cmp_eq_u32_e64 s[4:5], 0, v10 +; GISEL-NEXT: v_cndmask_b32_e64 v8, -1, v2, s[4:5] +; GISEL-NEXT: v_mul_lo_u32 v2, v15, v6 +; GISEL-NEXT: v_mul_lo_u32 v10, v12, v7 +; GISEL-NEXT: v_subbrev_u32_e32 v16, vcc, 0, v5, vcc +; GISEL-NEXT: v_mul_hi_u32 v5, v12, v6 +; GISEL-NEXT: v_add_i32_e32 v2, vcc, v2, v10 ; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v2, vcc, v7, v2 +; GISEL-NEXT: v_add_i32_e32 v2, vcc, v2, v5 ; GISEL-NEXT: v_cndmask_b32_e64 v2, 0, 1, vcc -; GISEL-NEXT: v_mul_lo_u32 v7, v15, v6 -; GISEL-NEXT: v_mul_hi_u32 v5, v15, v5 +; GISEL-NEXT: v_mul_lo_u32 v5, v15, v7 +; GISEL-NEXT: v_mul_hi_u32 v6, v15, v6 ; GISEL-NEXT: v_add_i32_e32 v2, vcc, v10, v2 -; GISEL-NEXT: v_mul_hi_u32 v10, v12, v6 -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v7, v5 -; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc +; GISEL-NEXT: v_mul_hi_u32 v10, v12, v7 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v6 +; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v10 ; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v10 -; GISEL-NEXT: v_mul_hi_u32 v6, v15, v6 +; GISEL-NEXT: v_add_i32_e32 v6, vcc, v6, v10 +; GISEL-NEXT: v_mul_hi_u32 v7, v15, v7 ; GISEL-NEXT: v_add_i32_e32 v2, vcc, v5, v2 ; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v7, v5 ; GISEL-NEXT: v_add_i32_e32 v5, vcc, v6, v5 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v12, v2 -; GISEL-NEXT: v_addc_u32_e32 v10, vcc, v15, v5, vcc -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v13, v7, 0 -; GISEL-NEXT: v_add_i32_e32 v12, vcc, 1, v0 -; GISEL-NEXT: v_addc_u32_e32 v15, vcc, 0, v4, vcc -; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v8, v1 -; GISEL-NEXT: v_mov_b32_e32 v1, v6 -; GISEL-NEXT: v_mad_u64_u32 v[1:2], s[4:5], v13, v10, v[1:2] -; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, -1, vcc -; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v16 -; GISEL-NEXT: v_mad_u64_u32 v[1:2], s[4:5], v14, v7, v[1:2] -; GISEL-NEXT: v_cndmask_b32_e32 v6, -1, v8, vcc -; GISEL-NEXT: v_add_i32_e32 v2, vcc, 1, v12 -; GISEL-NEXT: v_addc_u32_e32 v8, vcc, 0, v15, vcc -; GISEL-NEXT: v_mul_lo_u32 v13, v10, v5 -; GISEL-NEXT: v_mul_lo_u32 v14, v7, v1 -; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v6 -; GISEL-NEXT: v_mul_hi_u32 v6, v7, v5 -; GISEL-NEXT: v_cndmask_b32_e32 v2, v12, v2, vcc -; GISEL-NEXT: v_add_i32_e64 v12, s[4:5], v13, v14 -; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v6, s[4:5], v12, v6 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, s[4:5] -; GISEL-NEXT: v_mul_lo_u32 v12, v10, v1 -; GISEL-NEXT: v_mul_hi_u32 v5, v10, v5 -; GISEL-NEXT: v_add_i32_e64 v6, s[4:5], v13, v6 -; GISEL-NEXT: v_mul_hi_u32 v13, v7, v1 -; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v12, v5 -; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v5, v13 -; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v12, s[4:5], v12, v13 -; GISEL-NEXT: v_mul_hi_u32 v1, v10, v1 -; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v5, v6 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v6, s[4:5], v12, v6 -; GISEL-NEXT: v_add_i32_e64 v1, s[4:5], v1, v6 -; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v7, v5 -; GISEL-NEXT: v_addc_u32_e64 v1, s[4:5], v10, v1, s[4:5] +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v7, v5 +; GISEL-NEXT: v_add_i32_e32 v10, vcc, v12, v2 +; GISEL-NEXT: v_addc_u32_e32 v12, vcc, v15, v5, vcc +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v13, v10, 0 +; GISEL-NEXT: v_sub_i32_e32 v9, vcc, v9, v1 +; GISEL-NEXT: v_mov_b32_e32 v2, v6 +; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v13, v12, v[2:3] +; GISEL-NEXT: v_subbrev_u32_e32 v15, vcc, 0, v16, vcc +; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v14, v10, v[6:7] +; GISEL-NEXT: v_add_i32_e32 v2, vcc, 1, v0 +; GISEL-NEXT: v_addc_u32_e32 v13, vcc, 0, v4, vcc +; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v9, v1 +; GISEL-NEXT: v_mul_lo_u32 v7, v12, v5 +; GISEL-NEXT: v_mul_lo_u32 v9, v10, v6 +; GISEL-NEXT: v_mul_hi_u32 v14, v10, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v1, 0, -1, vcc +; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v15 +; GISEL-NEXT: v_cndmask_b32_e32 v1, -1, v1, vcc +; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v9 +; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v14 +; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc +; GISEL-NEXT: v_mul_lo_u32 v14, v12, v6 +; GISEL-NEXT: v_mul_hi_u32 v5, v12, v5 +; GISEL-NEXT: v_add_i32_e32 v7, vcc, v9, v7 +; GISEL-NEXT: v_mul_hi_u32 v9, v10, v6 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v14, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v14, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v9 +; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v9, vcc, v14, v9 +; GISEL-NEXT: v_mul_hi_u32 v6, v12, v6 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v7 +; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v7, vcc, v9, v7 +; GISEL-NEXT: v_add_i32_e32 v6, vcc, v6, v7 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v10, v5 +; GISEL-NEXT: v_addc_u32_e32 v7, vcc, v12, v6, vcc ; GISEL-NEXT: v_mul_lo_u32 v6, 0, v5 -; GISEL-NEXT: v_mul_lo_u32 v7, v11, v1 -; GISEL-NEXT: v_mul_hi_u32 v10, v11, v5 -; GISEL-NEXT: v_cndmask_b32_e32 v8, v15, v8, vcc +; GISEL-NEXT: v_mul_lo_u32 v9, v11, v7 +; GISEL-NEXT: v_mul_hi_u32 v14, v11, v5 +; GISEL-NEXT: v_add_i32_e32 v10, vcc, 1, v2 +; GISEL-NEXT: v_addc_u32_e32 v12, vcc, 0, v13, vcc +; GISEL-NEXT: v_add_i32_e32 v6, vcc, v6, v9 +; GISEL-NEXT: v_mul_lo_u32 v9, 0, v7 ; GISEL-NEXT: v_mul_hi_u32 v5, 0, v5 -; GISEL-NEXT: v_add_i32_e32 v6, vcc, v6, v7 -; GISEL-NEXT: v_mul_lo_u32 v7, 0, v1 -; GISEL-NEXT: v_add_i32_e32 v6, vcc, v6, v10 -; GISEL-NEXT: v_mul_hi_u32 v10, v11, v1 +; GISEL-NEXT: v_add_i32_e32 v6, vcc, v6, v14 +; GISEL-NEXT: v_mul_hi_u32 v14, v11, v7 ; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v7, v5 -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v10 -; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v5, v6 -; GISEL-NEXT: v_mul_hi_u32 v1, 0, v1 -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v3, v10, 0 -; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v12 -; GISEL-NEXT: v_add_i32_e32 v12, vcc, v1, v7 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v9, v5 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v14 +; GISEL-NEXT: v_add_i32_e32 v9, vcc, v5, v6 +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v3, v9, 0 +; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v1 +; GISEL-NEXT: v_cndmask_b32_e32 v2, v2, v10, vcc +; GISEL-NEXT: v_mul_hi_u32 v10, 0, v7 ; GISEL-NEXT: v_mov_b32_e32 v1, v6 -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v3, v12, v[1:2] -; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v9 +; GISEL-NEXT: v_cndmask_b32_e32 v12, v13, v12, vcc +; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v8 +; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v3, v10, v[1:2] ; GISEL-NEXT: v_cndmask_b32_e32 v0, v0, v2, vcc -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], 0, v10, v[6:7] -; GISEL-NEXT: v_cndmask_b32_e32 v1, v4, v8, vcc +; GISEL-NEXT: v_cndmask_b32_e32 v1, v4, v12, vcc +; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], 0, v9, v[6:7] ; GISEL-NEXT: v_sub_i32_e32 v2, vcc, v11, v5 ; GISEL-NEXT: v_sub_i32_e64 v5, s[4:5], 0, v6 ; GISEL-NEXT: v_subb_u32_e64 v4, s[4:5], 0, v6, vcc @@ -2743,8 +2736,8 @@ define <2 x i64> @v_sdiv_v2i64_24bit(<2 x i64> %num, <2 x i64> %den) { ; GISEL-NEXT: v_cmp_eq_u32_e64 s[4:5], 0, v4 ; GISEL-NEXT: v_subbrev_u32_e32 v5, vcc, 0, v5, vcc ; GISEL-NEXT: v_cndmask_b32_e64 v4, -1, v6, s[4:5] -; GISEL-NEXT: v_add_i32_e32 v6, vcc, 1, v10 -; GISEL-NEXT: v_addc_u32_e32 v7, vcc, 0, v12, vcc +; GISEL-NEXT: v_add_i32_e32 v6, vcc, 1, v9 +; GISEL-NEXT: v_addc_u32_e32 v7, vcc, 0, v10, vcc ; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v2, v3 ; GISEL-NEXT: v_cndmask_b32_e64 v2, 0, -1, vcc ; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v5 @@ -2755,8 +2748,8 @@ define <2 x i64> @v_sdiv_v2i64_24bit(<2 x i64> %num, <2 x i64> %den) { ; GISEL-NEXT: v_cndmask_b32_e32 v2, v6, v3, vcc ; GISEL-NEXT: v_cndmask_b32_e32 v3, v7, v5, vcc ; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v4 -; GISEL-NEXT: v_cndmask_b32_e32 v2, v10, v2, vcc -; GISEL-NEXT: v_cndmask_b32_e32 v3, v12, v3, vcc +; GISEL-NEXT: v_cndmask_b32_e32 v2, v9, v2, vcc +; GISEL-NEXT: v_cndmask_b32_e32 v3, v10, v3, vcc ; GISEL-NEXT: s_setpc_b64 s[30:31] ; ; CGP-LABEL: v_sdiv_v2i64_24bit: diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/smed3.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/smed3.ll index ac1e11b..dfa613c 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/smed3.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/smed3.ll @@ -1,7 +1,7 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py -; RUN: llc -global-isel -mtriple=amdgcn-amd-mesa3d -mcpu=gfx802 < %s | FileCheck -check-prefixes=GFX89,GFX8 %s -; RUN: llc -global-isel -mtriple=amdgcn-amd-mesa3d -mcpu=gfx900 < %s | FileCheck -check-prefixes=GFX89,GFX9 %s -; RUN: llc -global-isel -mtriple=amdgcn-amd-mesa3d -mcpu=gfx1010 < %s | FileCheck -check-prefix=GFX10 %s +; RUN: llc -global-isel -new-reg-bank-select -mtriple=amdgcn-amd-mesa3d -mcpu=gfx802 < %s | FileCheck -check-prefixes=GFX89,GFX8 %s +; RUN: llc -global-isel -new-reg-bank-select -mtriple=amdgcn-amd-mesa3d -mcpu=gfx900 < %s | FileCheck -check-prefixes=GFX89,GFX9 %s +; RUN: llc -global-isel -new-reg-bank-select -mtriple=amdgcn-amd-mesa3d -mcpu=gfx1010 < %s | FileCheck -check-prefix=GFX10 %s define i32 @test_min_max_ValK0_K1_i32(i32 %a) { ; GFX89-LABEL: test_min_max_ValK0_K1_i32: diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/srem.i64.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/srem.i64.ll index 82279e6..40b5db0 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/srem.i64.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/srem.i64.ll @@ -3035,203 +3035,193 @@ define <2 x i64> @v_srem_v2i64_24bit(<2 x i64> %num, <2 x i64> %den) { ; GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GISEL-NEXT: v_and_b32_e32 v1, 0xffffff, v4 ; GISEL-NEXT: v_cvt_f32_u32_e32 v3, v1 -; GISEL-NEXT: v_cvt_f32_ubyte0_e32 v4, 0 -; GISEL-NEXT: v_sub_i32_e32 v11, vcc, 0, v1 -; GISEL-NEXT: v_mac_f32_e32 v3, 0x4f800000, v4 +; GISEL-NEXT: v_cvt_f32_ubyte0_e32 v7, 0 +; GISEL-NEXT: v_sub_i32_e32 v9, vcc, 0, v1 +; GISEL-NEXT: v_mac_f32_e32 v3, 0x4f800000, v7 ; GISEL-NEXT: v_rcp_iflag_f32_e32 v3, v3 -; GISEL-NEXT: v_subb_u32_e64 v12, s[4:5], 0, 0, vcc +; GISEL-NEXT: v_subb_u32_e64 v10, s[4:5], 0, 0, vcc ; GISEL-NEXT: v_and_b32_e32 v2, 0xffffff, v2 ; GISEL-NEXT: v_mul_f32_e32 v3, 0x5f7ffffc, v3 -; GISEL-NEXT: v_mul_f32_e32 v5, 0x2f800000, v3 -; GISEL-NEXT: v_trunc_f32_e32 v5, v5 +; GISEL-NEXT: v_mul_f32_e32 v4, 0x2f800000, v3 +; GISEL-NEXT: v_trunc_f32_e32 v5, v4 ; GISEL-NEXT: v_mac_f32_e32 v3, 0xcf800000, v5 -; GISEL-NEXT: v_cvt_u32_f32_e32 v10, v3 -; GISEL-NEXT: v_cvt_u32_f32_e32 v5, v5 -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v11, v10, 0 -; GISEL-NEXT: v_mov_b32_e32 v3, v8 -; GISEL-NEXT: v_mad_u64_u32 v[8:9], s[4:5], v11, v5, v[3:4] -; GISEL-NEXT: v_mul_lo_u32 v3, v5, v7 -; GISEL-NEXT: v_mad_u64_u32 v[8:9], s[4:5], v12, v10, v[8:9] -; GISEL-NEXT: v_mul_hi_u32 v9, v10, v7 -; GISEL-NEXT: v_mul_hi_u32 v7, v5, v7 -; GISEL-NEXT: v_mul_lo_u32 v13, v10, v8 -; GISEL-NEXT: v_mul_lo_u32 v14, v5, v8 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v13 +; GISEL-NEXT: v_cvt_u32_f32_e32 v8, v3 +; GISEL-NEXT: v_cvt_u32_f32_e32 v11, v5 +; GISEL-NEXT: v_mad_u64_u32 v[3:4], s[4:5], v9, v8, 0 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v9, v11, v[4:5] +; GISEL-NEXT: v_mul_hi_u32 v12, v8, v3 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v10, v8, v[4:5] +; GISEL-NEXT: v_mul_lo_u32 v5, v11, v3 +; GISEL-NEXT: v_mul_hi_u32 v3, v11, v3 +; GISEL-NEXT: v_mul_lo_u32 v13, v8, v4 +; GISEL-NEXT: v_mul_lo_u32 v14, v11, v4 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v13 ; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v9 -; GISEL-NEXT: v_mul_hi_u32 v9, v10, v8 -; GISEL-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v13, v3 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v14, v7 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v12 +; GISEL-NEXT: v_mul_hi_u32 v12, v8, v4 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v13, v5 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v14, v3 ; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v9 -; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v9, vcc, v13, v9 -; GISEL-NEXT: v_mul_hi_u32 v8, v5, v8 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v7, v3 -; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v9, v7 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v8, v7 -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v10, v3 -; GISEL-NEXT: v_addc_u32_e32 v5, vcc, v5, v7, vcc -; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v11, v10, 0 -; GISEL-NEXT: v_mov_b32_e32 v3, v8 -; GISEL-NEXT: v_mad_u64_u32 v[8:9], s[4:5], v11, v5, v[3:4] -; GISEL-NEXT: v_mul_lo_u32 v3, v5, v7 -; GISEL-NEXT: v_and_b32_e32 v11, 0xffffff, v0 -; GISEL-NEXT: v_mad_u64_u32 v[8:9], s[4:5], v12, v10, v[8:9] -; GISEL-NEXT: v_mul_hi_u32 v0, v10, v7 -; GISEL-NEXT: v_mul_hi_u32 v7, v5, v7 -; GISEL-NEXT: v_mul_lo_u32 v9, v10, v8 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v9 -; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v3, v0 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v12 +; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v12, vcc, v13, v12 +; GISEL-NEXT: v_mul_hi_u32 v4, v11, v4 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v12, v5 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v5 +; GISEL-NEXT: v_add_i32_e32 v8, vcc, v8, v3 +; GISEL-NEXT: v_addc_u32_e32 v11, vcc, v11, v4, vcc +; GISEL-NEXT: v_mad_u64_u32 v[3:4], s[4:5], v9, v8, 0 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v9, v11, v[4:5] +; GISEL-NEXT: v_mul_hi_u32 v9, v8, v3 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v10, v8, v[4:5] +; GISEL-NEXT: v_and_b32_e32 v10, 0xffffff, v0 +; GISEL-NEXT: v_mul_lo_u32 v0, v11, v3 +; GISEL-NEXT: v_mul_lo_u32 v5, v8, v4 +; GISEL-NEXT: v_mul_hi_u32 v3, v11, v3 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v9 ; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, 1, vcc -; GISEL-NEXT: v_mul_lo_u32 v3, v5, v8 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v9, v0 -; GISEL-NEXT: v_mul_hi_u32 v9, v10, v8 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v7 -; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v9 +; GISEL-NEXT: v_mul_lo_u32 v9, v11, v4 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v5, v0 +; GISEL-NEXT: v_mul_hi_u32 v5, v8, v4 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v9, v3 ; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v9 -; GISEL-NEXT: v_mul_hi_u32 v8, v5, v8 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v3, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v9, v5 +; GISEL-NEXT: v_mul_hi_u32 v4, v11, v4 ; GISEL-NEXT: v_add_i32_e32 v0, vcc, v3, v0 ; GISEL-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v7, v3 -; GISEL-NEXT: v_add_i32_e32 v3, vcc, v8, v3 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v10, v0 -; GISEL-NEXT: v_addc_u32_e32 v5, vcc, v5, v3, vcc -; GISEL-NEXT: v_mul_lo_u32 v7, 0, v0 -; GISEL-NEXT: v_mul_lo_u32 v8, v11, v5 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v5, v3 +; GISEL-NEXT: v_add_i32_e32 v3, vcc, v4, v3 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v8, v0 +; GISEL-NEXT: v_addc_u32_e32 v8, vcc, v11, v3, vcc +; GISEL-NEXT: v_mul_lo_u32 v4, 0, v0 +; GISEL-NEXT: v_mul_lo_u32 v5, v10, v8 ; GISEL-NEXT: v_and_b32_e32 v3, 0xffffff, v6 -; GISEL-NEXT: v_mul_hi_u32 v6, v11, v0 +; GISEL-NEXT: v_mul_hi_u32 v6, v10, v0 ; GISEL-NEXT: v_mul_hi_u32 v0, 0, v0 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v8 -; GISEL-NEXT: v_mul_lo_u32 v8, 0, v5 -; GISEL-NEXT: v_add_i32_e32 v6, vcc, v7, v6 -; GISEL-NEXT: v_mul_hi_u32 v7, v11, v5 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v8, v0 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v7 -; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v8, vcc, v0, v6 -; GISEL-NEXT: v_mul_hi_u32 v9, 0, v5 -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v1, v8, 0 -; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v7, v0 -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v9, v0 -; GISEL-NEXT: v_mov_b32_e32 v0, v6 -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], v1, v7, v[0:1] -; GISEL-NEXT: v_cvt_f32_u32_e32 v0, v3 -; GISEL-NEXT: v_mad_u64_u32 v[6:7], s[4:5], 0, v8, v[6:7] -; GISEL-NEXT: v_mac_f32_e32 v0, 0x4f800000, v4 -; GISEL-NEXT: v_rcp_iflag_f32_e32 v0, v0 -; GISEL-NEXT: v_sub_i32_e32 v7, vcc, v11, v5 -; GISEL-NEXT: v_subb_u32_e64 v8, s[4:5], 0, v6, vcc -; GISEL-NEXT: v_mul_f32_e32 v0, 0x5f7ffffc, v0 -; GISEL-NEXT: v_mul_f32_e32 v4, 0x2f800000, v0 -; GISEL-NEXT: v_trunc_f32_e32 v9, v4 -; GISEL-NEXT: v_mac_f32_e32 v0, 0xcf800000, v9 -; GISEL-NEXT: v_cvt_u32_f32_e32 v10, v0 -; GISEL-NEXT: v_sub_i32_e64 v11, s[4:5], 0, v3 -; GISEL-NEXT: v_subb_u32_e64 v12, s[4:5], 0, 0, s[4:5] -; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v11, v10, 0 -; GISEL-NEXT: v_cvt_u32_f32_e32 v9, v9 -; GISEL-NEXT: v_sub_i32_e64 v13, s[4:5], 0, v6 -; GISEL-NEXT: v_mov_b32_e32 v0, v5 -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v11, v9, v[0:1] -; GISEL-NEXT: v_cmp_ge_u32_e64 s[4:5], v7, v1 -; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, -1, s[4:5] -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v12, v10, v[5:6] -; GISEL-NEXT: v_cmp_eq_u32_e64 s[4:5], 0, v8 -; GISEL-NEXT: v_cndmask_b32_e64 v14, -1, v0, s[4:5] -; GISEL-NEXT: v_mul_lo_u32 v0, v9, v4 -; GISEL-NEXT: v_mul_lo_u32 v6, v10, v5 -; GISEL-NEXT: v_mul_hi_u32 v15, v10, v4 -; GISEL-NEXT: v_subbrev_u32_e32 v13, vcc, 0, v13, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v6 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v15 -; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, 1, vcc -; GISEL-NEXT: v_mul_lo_u32 v15, v9, v5 -; GISEL-NEXT: v_mul_hi_u32 v4, v9, v4 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v6, v0 -; GISEL-NEXT: v_mul_hi_u32 v6, v10, v5 -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v15, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v15, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v5 +; GISEL-NEXT: v_mul_lo_u32 v5, 0, v8 ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v6 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v6, vcc, v15, v6 -; GISEL-NEXT: v_mul_hi_u32 v5, v9, v5 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v4, v0 +; GISEL-NEXT: v_mul_hi_u32 v6, v10, v8 ; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v6, v4 -; GISEL-NEXT: v_add_i32_e32 v4, vcc, v5, v4 -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v10, v0 -; GISEL-NEXT: v_addc_u32_e32 v9, vcc, v9, v4, vcc -; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v11, v10, 0 -; GISEL-NEXT: v_sub_i32_e32 v15, vcc, v7, v1 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v5, v0 +; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v6 +; GISEL-NEXT: v_add_i32_e32 v9, vcc, v0, v4 +; GISEL-NEXT: v_cvt_f32_u32_e32 v0, v3 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v1, v9, 0 +; GISEL-NEXT: v_mul_hi_u32 v6, 0, v8 +; GISEL-NEXT: v_mac_f32_e32 v0, 0x4f800000, v7 +; GISEL-NEXT: v_rcp_iflag_f32_e32 v7, v0 ; GISEL-NEXT: v_mov_b32_e32 v0, v5 -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v11, v9, v[0:1] -; GISEL-NEXT: v_subbrev_u32_e32 v13, vcc, 0, v13, vcc -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v12, v10, v[5:6] -; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v15, v1 -; GISEL-NEXT: v_cndmask_b32_e64 v16, 0, -1, vcc -; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v13 -; GISEL-NEXT: v_cndmask_b32_e32 v0, -1, v16, vcc -; GISEL-NEXT: v_sub_i32_e32 v1, vcc, v15, v1 -; GISEL-NEXT: v_subbrev_u32_e32 v6, vcc, 0, v13, vcc -; GISEL-NEXT: v_mul_lo_u32 v11, v9, v4 -; GISEL-NEXT: v_mul_lo_u32 v12, v10, v5 -; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v0 -; GISEL-NEXT: v_mul_hi_u32 v0, v10, v4 -; GISEL-NEXT: v_mul_hi_u32 v4, v9, v4 -; GISEL-NEXT: v_add_i32_e64 v11, s[4:5], v11, v12 -; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v0, s[4:5], v11, v0 -; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, 1, s[4:5] -; GISEL-NEXT: v_mul_lo_u32 v11, v9, v5 -; GISEL-NEXT: v_add_i32_e64 v0, s[4:5], v12, v0 -; GISEL-NEXT: v_mul_hi_u32 v12, v10, v5 -; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v11, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v11, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v4, v12 -; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v11, s[4:5], v11, v12 -; GISEL-NEXT: v_mul_hi_u32 v5, v9, v5 -; GISEL-NEXT: v_add_i32_e64 v0, s[4:5], v4, v0 +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v1, v6, v[0:1] +; GISEL-NEXT: v_mul_f32_e32 v0, 0x5f7ffffc, v7 +; GISEL-NEXT: v_mul_f32_e32 v7, 0x2f800000, v0 +; GISEL-NEXT: v_trunc_f32_e32 v11, v7 +; GISEL-NEXT: v_mac_f32_e32 v0, 0xcf800000, v11 +; GISEL-NEXT: v_cvt_u32_f32_e32 v12, v0 +; GISEL-NEXT: v_sub_i32_e32 v13, vcc, 0, v3 +; GISEL-NEXT: v_cvt_u32_f32_e32 v11, v11 +; GISEL-NEXT: v_mad_u64_u32 v[7:8], s[4:5], v13, v12, 0 +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], 0, v9, v[5:6] +; GISEL-NEXT: v_mov_b32_e32 v0, v8 +; GISEL-NEXT: v_mad_u64_u32 v[8:9], s[4:5], v13, v11, v[0:1] +; GISEL-NEXT: v_subb_u32_e64 v14, s[4:5], 0, 0, vcc +; GISEL-NEXT: v_mad_u64_u32 v[8:9], s[4:5], v14, v12, v[8:9] +; GISEL-NEXT: v_sub_i32_e32 v10, vcc, v10, v4 +; GISEL-NEXT: v_subb_u32_e64 v15, s[4:5], 0, v5, vcc +; GISEL-NEXT: v_sub_i32_e64 v0, s[4:5], 0, v5 +; GISEL-NEXT: v_mul_lo_u32 v4, v11, v7 +; GISEL-NEXT: v_mul_lo_u32 v5, v12, v8 +; GISEL-NEXT: v_mul_hi_u32 v9, v12, v7 +; GISEL-NEXT: v_cmp_ge_u32_e64 s[4:5], v10, v1 +; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, -1, s[4:5] +; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v4, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, s[4:5] +; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v4, v9 ; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, s[4:5] -; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v11, v4 +; GISEL-NEXT: v_mul_lo_u32 v9, v11, v8 +; GISEL-NEXT: v_mul_hi_u32 v7, v11, v7 ; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v5, v4 -; GISEL-NEXT: v_add_i32_e64 v0, s[4:5], v10, v0 -; GISEL-NEXT: v_addc_u32_e64 v4, s[4:5], v9, v4, s[4:5] -; GISEL-NEXT: v_mul_lo_u32 v5, 0, v0 -; GISEL-NEXT: v_mul_lo_u32 v9, v2, v4 -; GISEL-NEXT: v_cndmask_b32_e32 v10, v13, v6, vcc -; GISEL-NEXT: v_mul_hi_u32 v6, v2, v0 -; GISEL-NEXT: v_cndmask_b32_e32 v1, v15, v1, vcc -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v9 -; GISEL-NEXT: v_mul_lo_u32 v9, 0, v4 -; GISEL-NEXT: v_mul_hi_u32 v0, 0, v0 -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v6 -; GISEL-NEXT: v_mul_hi_u32 v6, v2, v4 +; GISEL-NEXT: v_mul_hi_u32 v5, v12, v8 +; GISEL-NEXT: v_add_i32_e64 v7, s[4:5], v9, v7 +; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, s[4:5] +; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v7, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, 1, s[4:5] +; GISEL-NEXT: v_add_i32_e64 v7, s[4:5], v9, v7 +; GISEL-NEXT: v_mul_hi_u32 v8, v11, v8 +; GISEL-NEXT: v_add_i32_e64 v4, s[4:5], v5, v4 +; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, s[4:5] +; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v7, v5 +; GISEL-NEXT: v_add_i32_e64 v5, s[4:5], v8, v5 +; GISEL-NEXT: v_add_i32_e64 v7, s[4:5], v12, v4 +; GISEL-NEXT: v_addc_u32_e64 v8, s[4:5], v11, v5, s[4:5] +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v13, v7, 0 +; GISEL-NEXT: v_cmp_eq_u32_e64 s[4:5], 0, v15 +; GISEL-NEXT: v_subbrev_u32_e32 v11, vcc, 0, v0, vcc +; GISEL-NEXT: v_mov_b32_e32 v0, v5 +; GISEL-NEXT: v_cndmask_b32_e64 v9, -1, v6, s[4:5] +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v13, v8, v[0:1] +; GISEL-NEXT: v_sub_i32_e32 v0, vcc, v10, v1 +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v14, v7, v[5:6] +; GISEL-NEXT: v_mul_lo_u32 v12, v8, v4 +; GISEL-NEXT: v_subbrev_u32_e32 v11, vcc, 0, v11, vcc +; GISEL-NEXT: v_mul_lo_u32 v13, v7, v5 +; GISEL-NEXT: v_mul_hi_u32 v14, v7, v4 +; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v0, v1 +; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, -1, vcc +; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v11 +; GISEL-NEXT: v_cndmask_b32_e32 v6, -1, v6, vcc +; GISEL-NEXT: v_add_i32_e32 v12, vcc, v12, v13 +; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v12, vcc, v12, v14 +; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, vcc +; GISEL-NEXT: v_mul_lo_u32 v14, v8, v5 +; GISEL-NEXT: v_mul_hi_u32 v4, v8, v4 +; GISEL-NEXT: v_add_i32_e32 v12, vcc, v13, v12 +; GISEL-NEXT: v_mul_hi_u32 v13, v7, v5 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v14, v4 +; GISEL-NEXT: v_cndmask_b32_e64 v14, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v13 +; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v13, vcc, v14, v13 +; GISEL-NEXT: v_mul_hi_u32 v5, v8, v5 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v12 +; GISEL-NEXT: v_cndmask_b32_e64 v12, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v12, vcc, v13, v12 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v12 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v7, v4 +; GISEL-NEXT: v_addc_u32_e32 v7, vcc, v8, v5, vcc +; GISEL-NEXT: v_mul_lo_u32 v5, 0, v4 +; GISEL-NEXT: v_mul_lo_u32 v8, v2, v7 +; GISEL-NEXT: v_mul_hi_u32 v13, v2, v4 +; GISEL-NEXT: v_sub_i32_e32 v1, vcc, v0, v1 +; GISEL-NEXT: v_subbrev_u32_e32 v12, vcc, 0, v11, vcc +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v8 +; GISEL-NEXT: v_mul_lo_u32 v8, 0, v7 +; GISEL-NEXT: v_mul_hi_u32 v4, 0, v4 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v13 +; GISEL-NEXT: v_mul_hi_u32 v13, v2, v7 ; GISEL-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v9, v0 -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v0, v6 -; GISEL-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v9, vcc, v0, v5 -; GISEL-NEXT: v_mul_hi_u32 v11, 0, v4 -; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v3, v9, 0 -; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v0, vcc, v6, v0 -; GISEL-NEXT: v_add_i32_e32 v6, vcc, v11, v0 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v8, v4 +; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v13 +; GISEL-NEXT: v_add_i32_e32 v8, vcc, v4, v5 +; GISEL-NEXT: v_mad_u64_u32 v[4:5], s[4:5], v3, v8, 0 +; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v6 +; GISEL-NEXT: v_mul_hi_u32 v6, 0, v7 +; GISEL-NEXT: v_cndmask_b32_e32 v1, v0, v1, vcc ; GISEL-NEXT: v_mov_b32_e32 v0, v5 +; GISEL-NEXT: v_cndmask_b32_e32 v7, v11, v12, vcc ; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], v3, v6, v[0:1] -; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v14 -; GISEL-NEXT: v_cndmask_b32_e32 v0, v7, v1, vcc -; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], 0, v9, v[5:6] -; GISEL-NEXT: v_cndmask_b32_e32 v1, v8, v10, vcc +; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v9 +; GISEL-NEXT: v_cndmask_b32_e32 v0, v10, v1, vcc +; GISEL-NEXT: v_mad_u64_u32 v[5:6], s[4:5], 0, v8, v[5:6] +; GISEL-NEXT: v_cndmask_b32_e32 v1, v15, v7, vcc ; GISEL-NEXT: v_sub_i32_e32 v2, vcc, v2, v4 ; GISEL-NEXT: v_subb_u32_e64 v4, s[4:5], 0, v5, vcc ; GISEL-NEXT: v_sub_i32_e64 v5, s[4:5], 0, v5 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/udiv.i64.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/udiv.i64.ll index 4de1078..ded985e 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/udiv.i64.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/udiv.i64.ll @@ -2053,90 +2053,82 @@ define <2 x i64> @v_udiv_v2i64_24bit(<2 x i64> %num, <2 x i64> %den) { ; GISEL-NEXT: v_mul_lo_u32 v12, v6, v2 ; GISEL-NEXT: v_mul_lo_u32 v13, 0, v2 ; GISEL-NEXT: v_mul_hi_u32 v14, v6, v2 -; GISEL-NEXT: v_mul_hi_u32 v2, 0, v2 -; GISEL-NEXT: v_mul_lo_u32 v15, v0, v5 +; GISEL-NEXT: v_mul_hi_u32 v15, 0, v2 +; GISEL-NEXT: v_mul_lo_u32 v2, v0, v5 ; GISEL-NEXT: v_mul_lo_u32 v16, 0, v5 ; GISEL-NEXT: v_mul_hi_u32 v17, v0, v5 ; GISEL-NEXT: v_mul_hi_u32 v5, 0, v5 ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v12 ; GISEL-NEXT: v_add_i32_e32 v8, vcc, v13, v8 -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v10, v15 +; GISEL-NEXT: v_mul_lo_u32 v12, v3, v15 +; GISEL-NEXT: v_add_i32_e32 v2, vcc, v10, v2 ; GISEL-NEXT: v_add_i32_e32 v7, vcc, v16, v7 +; GISEL-NEXT: v_mul_lo_u32 v10, v1, v5 ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v9 ; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v8, vcc, v8, v14 -; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v10, v11 -; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc +; GISEL-NEXT: v_add_i32_e32 v2, vcc, v2, v11 +; GISEL-NEXT: v_cndmask_b32_e64 v2, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v17 -; GISEL-NEXT: v_cndmask_b32_e64 v11, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v8, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v10 -; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v8, vcc, v9, v8 -; GISEL-NEXT: v_mul_lo_u32 v9, v3, v4 -; GISEL-NEXT: v_mul_lo_u32 v12, 0, v4 -; GISEL-NEXT: v_mul_hi_u32 v13, v3, v4 -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v11, v10 -; GISEL-NEXT: v_mul_lo_u32 v11, v1, v7 -; GISEL-NEXT: v_mul_lo_u32 v14, 0, v7 -; GISEL-NEXT: v_mul_hi_u32 v15, v1, v7 -; GISEL-NEXT: v_add_i32_e32 v8, vcc, v2, v8 -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v10 -; GISEL-NEXT: v_mul_lo_u32 v2, v3, v8 -; GISEL-NEXT: v_add_i32_e32 v10, vcc, 1, v4 -; GISEL-NEXT: v_addc_u32_e32 v16, vcc, 0, v8, vcc -; GISEL-NEXT: v_mul_lo_u32 v17, v1, v5 -; GISEL-NEXT: v_add_i32_e32 v18, vcc, 1, v7 +; GISEL-NEXT: v_add_i32_e32 v2, vcc, v7, v2 +; GISEL-NEXT: v_mul_lo_u32 v7, v3, v4 +; GISEL-NEXT: v_mul_lo_u32 v8, 0, v4 +; GISEL-NEXT: v_mul_hi_u32 v9, v3, v4 +; GISEL-NEXT: v_add_i32_e32 v11, vcc, 1, v4 +; GISEL-NEXT: v_addc_u32_e32 v13, vcc, 0, v15, vcc +; GISEL-NEXT: v_mul_lo_u32 v14, v1, v2 +; GISEL-NEXT: v_mul_lo_u32 v16, 0, v2 +; GISEL-NEXT: v_mul_hi_u32 v17, v1, v2 +; GISEL-NEXT: v_add_i32_e32 v18, vcc, 1, v2 ; GISEL-NEXT: v_addc_u32_e32 v19, vcc, 0, v5, vcc -; GISEL-NEXT: v_add_i32_e32 v2, vcc, v12, v2 -; GISEL-NEXT: v_add_i32_e32 v12, vcc, v14, v17 -; GISEL-NEXT: v_add_i32_e32 v14, vcc, 1, v10 -; GISEL-NEXT: v_addc_u32_e32 v17, vcc, 0, v16, vcc -; GISEL-NEXT: v_add_i32_e32 v2, vcc, v2, v13 -; GISEL-NEXT: v_add_i32_e32 v12, vcc, v12, v15 -; GISEL-NEXT: v_sub_i32_e32 v6, vcc, v6, v9 -; GISEL-NEXT: v_subb_u32_e64 v9, s[4:5], 0, v2, vcc +; GISEL-NEXT: v_add_i32_e32 v8, vcc, v8, v12 +; GISEL-NEXT: v_add_i32_e32 v10, vcc, v16, v10 +; GISEL-NEXT: v_add_i32_e32 v12, vcc, 1, v11 +; GISEL-NEXT: v_addc_u32_e32 v16, vcc, 0, v13, vcc +; GISEL-NEXT: v_add_i32_e32 v8, vcc, v8, v9 +; GISEL-NEXT: v_add_i32_e32 v9, vcc, v10, v17 +; GISEL-NEXT: v_sub_i32_e32 v6, vcc, v6, v7 +; GISEL-NEXT: v_subb_u32_e64 v7, s[4:5], 0, v8, vcc ; GISEL-NEXT: v_cmp_ge_u32_e64 s[4:5], v6, v3 -; GISEL-NEXT: v_cndmask_b32_e64 v13, 0, -1, s[4:5] -; GISEL-NEXT: v_sub_i32_e64 v0, s[4:5], v0, v11 -; GISEL-NEXT: v_subb_u32_e64 v11, s[6:7], 0, v12, s[4:5] +; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, -1, s[4:5] +; GISEL-NEXT: v_sub_i32_e64 v0, s[4:5], v0, v14 +; GISEL-NEXT: v_subb_u32_e64 v14, s[6:7], 0, v9, s[4:5] ; GISEL-NEXT: v_cmp_ge_u32_e64 s[6:7], v0, v1 -; GISEL-NEXT: v_cndmask_b32_e64 v15, 0, -1, s[6:7] -; GISEL-NEXT: v_cmp_eq_u32_e64 s[6:7], 0, v9 -; GISEL-NEXT: v_cmp_eq_u32_e64 s[8:9], 0, v11 -; GISEL-NEXT: v_add_i32_e64 v9, s[10:11], 1, v18 -; GISEL-NEXT: v_addc_u32_e64 v11, s[10:11], 0, v19, s[10:11] -; GISEL-NEXT: v_sub_i32_e64 v2, s[10:11], 0, v2 -; GISEL-NEXT: v_sub_i32_e64 v12, s[10:11], 0, v12 -; GISEL-NEXT: v_cndmask_b32_e64 v13, -1, v13, s[6:7] -; GISEL-NEXT: v_subbrev_u32_e32 v2, vcc, 0, v2, vcc -; GISEL-NEXT: v_cndmask_b32_e64 v15, -1, v15, s[8:9] -; GISEL-NEXT: v_subbrev_u32_e64 v12, vcc, 0, v12, s[4:5] +; GISEL-NEXT: v_cndmask_b32_e64 v17, 0, -1, s[6:7] +; GISEL-NEXT: v_cmp_eq_u32_e64 s[6:7], 0, v7 +; GISEL-NEXT: v_cmp_eq_u32_e64 s[8:9], 0, v14 +; GISEL-NEXT: v_add_i32_e64 v7, s[10:11], 1, v18 +; GISEL-NEXT: v_addc_u32_e64 v14, s[10:11], 0, v19, s[10:11] +; GISEL-NEXT: v_sub_i32_e64 v8, s[10:11], 0, v8 +; GISEL-NEXT: v_sub_i32_e64 v9, s[10:11], 0, v9 +; GISEL-NEXT: v_cndmask_b32_e64 v10, -1, v10, s[6:7] +; GISEL-NEXT: v_subbrev_u32_e32 v8, vcc, 0, v8, vcc +; GISEL-NEXT: v_cndmask_b32_e64 v17, -1, v17, s[8:9] +; GISEL-NEXT: v_subbrev_u32_e64 v9, vcc, 0, v9, s[4:5] ; GISEL-NEXT: v_sub_i32_e32 v6, vcc, v6, v3 -; GISEL-NEXT: v_subbrev_u32_e32 v2, vcc, 0, v2, vcc +; GISEL-NEXT: v_subbrev_u32_e32 v8, vcc, 0, v8, vcc ; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v6, v3 ; GISEL-NEXT: v_cndmask_b32_e64 v3, 0, -1, vcc ; GISEL-NEXT: v_sub_i32_e32 v0, vcc, v0, v1 -; GISEL-NEXT: v_subbrev_u32_e32 v6, vcc, 0, v12, vcc +; GISEL-NEXT: v_subbrev_u32_e32 v6, vcc, 0, v9, vcc ; GISEL-NEXT: v_cmp_ge_u32_e32 vcc, v0, v1 ; GISEL-NEXT: v_cndmask_b32_e64 v0, 0, -1, vcc -; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v2 +; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v8 ; GISEL-NEXT: v_cndmask_b32_e32 v1, -1, v3, vcc ; GISEL-NEXT: v_cmp_eq_u32_e32 vcc, 0, v6 ; GISEL-NEXT: v_cndmask_b32_e32 v0, -1, v0, vcc ; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v1 -; GISEL-NEXT: v_cndmask_b32_e32 v1, v10, v14, vcc +; GISEL-NEXT: v_cndmask_b32_e32 v1, v11, v12, vcc ; GISEL-NEXT: v_cmp_ne_u32_e64 s[4:5], 0, v0 -; GISEL-NEXT: v_cndmask_b32_e64 v2, v18, v9, s[4:5] -; GISEL-NEXT: v_cndmask_b32_e32 v3, v16, v17, vcc -; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v13 +; GISEL-NEXT: v_cndmask_b32_e64 v3, v18, v7, s[4:5] +; GISEL-NEXT: v_cndmask_b32_e32 v6, v13, v16, vcc +; GISEL-NEXT: v_cmp_ne_u32_e32 vcc, 0, v10 ; GISEL-NEXT: v_cndmask_b32_e32 v0, v4, v1, vcc -; GISEL-NEXT: v_cndmask_b32_e64 v4, v19, v11, s[4:5] -; GISEL-NEXT: v_cmp_ne_u32_e64 s[4:5], 0, v15 -; GISEL-NEXT: v_cndmask_b32_e64 v2, v7, v2, s[4:5] -; GISEL-NEXT: v_cndmask_b32_e32 v1, v8, v3, vcc +; GISEL-NEXT: v_cndmask_b32_e64 v4, v19, v14, s[4:5] +; GISEL-NEXT: v_cmp_ne_u32_e64 s[4:5], 0, v17 +; GISEL-NEXT: v_cndmask_b32_e64 v2, v2, v3, s[4:5] +; GISEL-NEXT: v_cndmask_b32_e32 v1, v15, v6, vcc ; GISEL-NEXT: v_cndmask_b32_e64 v3, v5, v4, s[4:5] ; GISEL-NEXT: s_setpc_b64 s[30:31] ; diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/umed3.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/umed3.ll index 2b54123..f5068f5 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/umed3.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/umed3.ll @@ -1,7 +1,7 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py -; RUN: llc -global-isel -mtriple=amdgcn-amd-mesa3d -mcpu=gfx802 < %s | FileCheck -check-prefixes=GFX89,GFX8 %s -; RUN: llc -global-isel -mtriple=amdgcn-amd-mesa3d -mcpu=gfx900 < %s | FileCheck -check-prefixes=GFX89,GFX9 %s -; RUN: llc -global-isel -mtriple=amdgcn-amd-mesa3d -mcpu=gfx1010 < %s | FileCheck -check-prefix=GFX10 %s +; RUN: llc -global-isel -new-reg-bank-select -mtriple=amdgcn-amd-mesa3d -mcpu=gfx802 < %s | FileCheck -check-prefixes=GFX89,GFX8 %s +; RUN: llc -global-isel -new-reg-bank-select -mtriple=amdgcn-amd-mesa3d -mcpu=gfx900 < %s | FileCheck -check-prefixes=GFX89,GFX9 %s +; RUN: llc -global-isel -new-reg-bank-select -mtriple=amdgcn-amd-mesa3d -mcpu=gfx1010 < %s | FileCheck -check-prefix=GFX10 %s define i32 @test_min_max_ValK0_K1_u32(i32 %a) { ; GFX89-LABEL: test_min_max_ValK0_K1_u32: diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/urem.i64.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/urem.i64.ll index a41ec8e..be5543b 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/urem.i64.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/urem.i64.ll @@ -2058,42 +2058,34 @@ define <2 x i64> @v_urem_v2i64_24bit(<2 x i64> %num, <2 x i64> %den) { ; GISEL-NEXT: v_mul_hi_u32 v5, 0, v5 ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v12 ; GISEL-NEXT: v_add_i32_e32 v8, vcc, v13, v8 +; GISEL-NEXT: v_mul_lo_u32 v2, v3, v2 ; GISEL-NEXT: v_add_i32_e32 v10, vcc, v10, v15 ; GISEL-NEXT: v_add_i32_e32 v7, vcc, v16, v7 +; GISEL-NEXT: v_mul_lo_u32 v5, v1, v5 ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v4, v9 ; GISEL-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v8, vcc, v8, v14 +; GISEL-NEXT: v_add_i32_e32 v9, vcc, v10, v11 ; GISEL-NEXT: v_cndmask_b32_e64 v9, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v10, v11 -; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v17 -; GISEL-NEXT: v_cndmask_b32_e64 v11, 0, 1, vcc ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v8, v4 -; GISEL-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v10 -; GISEL-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GISEL-NEXT: v_add_i32_e32 v8, vcc, v9, v8 -; GISEL-NEXT: v_mul_lo_u32 v9, v3, v4 -; GISEL-NEXT: v_mul_lo_u32 v12, 0, v4 +; GISEL-NEXT: v_add_i32_e32 v7, vcc, v7, v9 +; GISEL-NEXT: v_mul_lo_u32 v8, v3, v4 +; GISEL-NEXT: v_mul_lo_u32 v9, 0, v4 ; GISEL-NEXT: v_mul_hi_u32 v4, v3, v4 -; GISEL-NEXT: v_add_i32_e32 v10, vcc, v11, v10 -; GISEL-NEXT: v_mul_lo_u32 v11, v1, v7 -; GISEL-NEXT: v_mul_lo_u32 v13, 0, v7 +; GISEL-NEXT: v_mul_lo_u32 v10, v1, v7 +; GISEL-NEXT: v_mul_lo_u32 v11, 0, v7 ; GISEL-NEXT: v_mul_hi_u32 v7, v1, v7 -; GISEL-NEXT: v_add_i32_e32 v2, vcc, v2, v8 -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v5, v10 -; GISEL-NEXT: v_mul_lo_u32 v2, v3, v2 -; GISEL-NEXT: v_mul_lo_u32 v5, v1, v5 -; GISEL-NEXT: v_add_i32_e32 v2, vcc, v12, v2 -; GISEL-NEXT: v_add_i32_e32 v5, vcc, v13, v5 +; GISEL-NEXT: v_add_i32_e32 v2, vcc, v9, v2 +; GISEL-NEXT: v_add_i32_e32 v5, vcc, v11, v5 ; GISEL-NEXT: v_add_i32_e32 v2, vcc, v2, v4 ; GISEL-NEXT: v_add_i32_e32 v4, vcc, v5, v7 -; GISEL-NEXT: v_sub_i32_e32 v5, vcc, v6, v9 +; GISEL-NEXT: v_sub_i32_e32 v5, vcc, v6, v8 ; GISEL-NEXT: v_subb_u32_e64 v6, s[4:5], 0, v2, vcc ; GISEL-NEXT: v_sub_i32_e64 v2, s[4:5], 0, v2 ; GISEL-NEXT: v_cmp_ge_u32_e64 s[4:5], v5, v3 ; GISEL-NEXT: v_cndmask_b32_e64 v7, 0, -1, s[4:5] -; GISEL-NEXT: v_sub_i32_e64 v8, s[4:5], v0, v11 +; GISEL-NEXT: v_sub_i32_e64 v8, s[4:5], v0, v10 ; GISEL-NEXT: v_subb_u32_e64 v9, s[6:7], 0, v4, s[4:5] ; GISEL-NEXT: v_sub_i32_e64 v0, s[6:7], 0, v4 ; GISEL-NEXT: v_cmp_ge_u32_e64 s[6:7], v8, v1 diff --git a/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-break-large-phis-heuristics.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-break-large-phis-heuristics.ll index c94b333..1f36902 100644 --- a/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-break-large-phis-heuristics.ll +++ b/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-break-large-phis-heuristics.ll @@ -726,16 +726,16 @@ define amdgpu_kernel void @used_by_unbreakable_and_breakable_phi(<5 x double> %i ; CHECK-NEXT: [[LARGEPHI_EXTRACTSLICE815:%.*]] = extractelement <5 x double> [[LARGEPHI_INSERTSLICE4]], i64 4 ; CHECK-NEXT: br label [[END]] ; CHECK: end: -; CHECK-NEXT: [[TMP5:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE01]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE1]], [[FINALLY]] ] -; CHECK-NEXT: [[TMP6:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE22]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE3]], [[FINALLY]] ] -; CHECK-NEXT: [[TMP7:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE43]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE5]], [[FINALLY]] ] -; CHECK-NEXT: [[TMP8:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE64]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE7]], [[FINALLY]] ] -; CHECK-NEXT: [[TMP9:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE85]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE9]], [[FINALLY]] ] -; CHECK-NEXT: [[TMP10:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE011]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] -; CHECK-NEXT: [[TMP11:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE212]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] -; CHECK-NEXT: [[TMP12:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE413]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] -; CHECK-NEXT: [[TMP13:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE614]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] -; CHECK-NEXT: [[TMP14:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE815]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] +; CHECK-NEXT: [[TMP5:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE01]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] +; CHECK-NEXT: [[TMP6:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE22]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] +; CHECK-NEXT: [[TMP7:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE43]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] +; CHECK-NEXT: [[TMP8:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE64]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] +; CHECK-NEXT: [[TMP9:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE85]], [[THEN1]] ], [ 0.000000e+00, [[FINALLY]] ] +; CHECK-NEXT: [[TMP10:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE011]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE1]], [[FINALLY]] ] +; CHECK-NEXT: [[TMP11:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE212]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE3]], [[FINALLY]] ] +; CHECK-NEXT: [[TMP12:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE413]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE5]], [[FINALLY]] ] +; CHECK-NEXT: [[TMP13:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE614]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE7]], [[FINALLY]] ] +; CHECK-NEXT: [[TMP14:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE815]], [[THEN1]] ], [ [[LARGEPHI_EXTRACTSLICE9]], [[FINALLY]] ] ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE016:%.*]] = insertelement <5 x double> poison, double [[TMP10]], i64 0 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE117:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE016]], double [[TMP11]], i64 1 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE218:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE117]], double [[TMP12]], i64 2 @@ -746,8 +746,8 @@ define amdgpu_kernel void @used_by_unbreakable_and_breakable_phi(<5 x double> %i ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE28:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE17]], double [[TMP7]], i64 2 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE39:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE28]], double [[TMP8]], i64 3 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE410:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE39]], double [[TMP9]], i64 4 -; CHECK-NEXT: store <5 x double> [[LARGEPHI_INSERTSLICE410]], ptr [[OUT]], align 1 ; CHECK-NEXT: store <5 x double> [[LARGEPHI_INSERTSLICE420]], ptr [[OUT]], align 1 +; CHECK-NEXT: store <5 x double> [[LARGEPHI_INSERTSLICE410]], ptr [[OUT]], align 1 ; CHECK-NEXT: ret void ; entry: @@ -1187,11 +1187,11 @@ define amdgpu_kernel void @test_breakable_chain_5_out_of_7(<5 x double> %in, ptr ; CHECK-NEXT: [[LARGEPHI_EXTRACTSLICE960:%.*]] = extractelement <5 x double> [[IN]], i64 4 ; CHECK-NEXT: br i1 [[COND]], label [[END:%.*]], label [[COND5_END]] ; CHECK: cond5.end: -; CHECK-NEXT: [[TMP25:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE041]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE1]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP26:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE242]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE3]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP27:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE443]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE5]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP28:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE644]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE7]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP29:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE845]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE9]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP25:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE041]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE152]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP26:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE242]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE354]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP27:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE443]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE556]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP28:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE644]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE758]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP29:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE845]], [[COND4_END]] ], [ [[LARGEPHI_EXTRACTSLICE960]], [[COND5_TRUE]] ] ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE046:%.*]] = insertelement <5 x double> poison, double [[TMP25]], i64 0 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE147:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE046]], double [[TMP26]], i64 1 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE248:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE147]], double [[TMP27]], i64 2 @@ -1204,11 +1204,11 @@ define amdgpu_kernel void @test_breakable_chain_5_out_of_7(<5 x double> %in, ptr ; CHECK-NEXT: [[LARGEPHI_EXTRACTSLICE859:%.*]] = extractelement <5 x double> [[LARGEPHI_INSERTSLICE450]], i64 4 ; CHECK-NEXT: br label [[END]] ; CHECK: end: -; CHECK-NEXT: [[TMP30:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE051]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE152]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP31:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE253]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE354]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP32:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE455]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE556]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP33:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE657]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE758]], [[COND5_TRUE]] ] -; CHECK-NEXT: [[TMP34:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE859]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE960]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP30:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE051]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE1]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP31:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE253]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE3]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP32:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE455]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE5]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP33:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE657]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE7]], [[COND5_TRUE]] ] +; CHECK-NEXT: [[TMP34:%.*]] = phi double [ [[LARGEPHI_EXTRACTSLICE859]], [[COND5_END]] ], [ [[LARGEPHI_EXTRACTSLICE9]], [[COND5_TRUE]] ] ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE061:%.*]] = insertelement <5 x double> poison, double [[TMP30]], i64 0 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE162:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE061]], double [[TMP31]], i64 1 ; CHECK-NEXT: [[LARGEPHI_INSERTSLICE263:%.*]] = insertelement <5 x double> [[LARGEPHI_INSERTSLICE162]], double [[TMP32]], i64 2 diff --git a/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.ll index a4f9ce3..7ff86ac 100644 --- a/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.ll +++ b/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.ll @@ -2160,7 +2160,22 @@ define amdgpu_kernel void @rsq_f32_vector_fpmath(ptr addrspace(1) %out, <2 x flo ; IEEE-GOODFREXP-NEXT: [[TMP38:%.*]] = insertelement <2 x float> poison, float [[TMP27]], i64 0 ; IEEE-GOODFREXP-NEXT: [[MD_1ULP_UNDEF:%.*]] = insertelement <2 x float> [[TMP38]], float [[TMP37]], i64 1 ; IEEE-GOODFREXP-NEXT: store volatile <2 x float> [[MD_1ULP_UNDEF]], ptr addrspace(1) [[OUT]], align 4 -; IEEE-GOODFREXP-NEXT: [[SQRT_X_3ULP:%.*]] = call contract <2 x float> @llvm.sqrt.v2f32(<2 x float> [[X]]), !fpmath [[META3:![0-9]+]] +; IEEE-GOODFREXP-NEXT: [[TMP56:%.*]] = extractelement <2 x float> [[X]], i64 0 +; IEEE-GOODFREXP-NEXT: [[TMP57:%.*]] = extractelement <2 x float> [[X]], i64 1 +; IEEE-GOODFREXP-NEXT: [[TMP58:%.*]] = fcmp olt float [[TMP56]], 0x3810000000000000 +; IEEE-GOODFREXP-NEXT: [[TMP59:%.*]] = select i1 [[TMP58]], i32 32, i32 0 +; IEEE-GOODFREXP-NEXT: [[TMP60:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP56]], i32 [[TMP59]]) +; IEEE-GOODFREXP-NEXT: [[TMP61:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP60]]) +; IEEE-GOODFREXP-NEXT: [[TMP62:%.*]] = select i1 [[TMP58]], i32 -16, i32 0 +; IEEE-GOODFREXP-NEXT: [[TMP63:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP61]], i32 [[TMP62]]) +; IEEE-GOODFREXP-NEXT: [[TMP64:%.*]] = fcmp olt float [[TMP57]], 0x3810000000000000 +; IEEE-GOODFREXP-NEXT: [[TMP65:%.*]] = select i1 [[TMP64]], i32 32, i32 0 +; IEEE-GOODFREXP-NEXT: [[TMP66:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP57]], i32 [[TMP65]]) +; IEEE-GOODFREXP-NEXT: [[TMP67:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP66]]) +; IEEE-GOODFREXP-NEXT: [[TMP68:%.*]] = select i1 [[TMP64]], i32 -16, i32 0 +; IEEE-GOODFREXP-NEXT: [[TMP69:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP67]], i32 [[TMP68]]) +; IEEE-GOODFREXP-NEXT: [[TMP70:%.*]] = insertelement <2 x float> poison, float [[TMP63]], i64 0 +; IEEE-GOODFREXP-NEXT: [[SQRT_X_3ULP:%.*]] = insertelement <2 x float> [[TMP70]], float [[TMP69]], i64 1 ; IEEE-GOODFREXP-NEXT: [[TMP39:%.*]] = extractelement <2 x float> [[SQRT_X_3ULP]], i64 0 ; IEEE-GOODFREXP-NEXT: [[TMP40:%.*]] = extractelement <2 x float> [[SQRT_X_3ULP]], i64 1 ; IEEE-GOODFREXP-NEXT: [[TMP41:%.*]] = extractelement <2 x float> [[X]], i64 0 @@ -2231,7 +2246,22 @@ define amdgpu_kernel void @rsq_f32_vector_fpmath(ptr addrspace(1) %out, <2 x flo ; IEEE-BADFREXP-NEXT: [[TMP38:%.*]] = insertelement <2 x float> poison, float [[TMP27]], i64 0 ; IEEE-BADFREXP-NEXT: [[MD_1ULP_UNDEF:%.*]] = insertelement <2 x float> [[TMP38]], float [[TMP37]], i64 1 ; IEEE-BADFREXP-NEXT: store volatile <2 x float> [[MD_1ULP_UNDEF]], ptr addrspace(1) [[OUT]], align 4 -; IEEE-BADFREXP-NEXT: [[SQRT_X_3ULP:%.*]] = call contract <2 x float> @llvm.sqrt.v2f32(<2 x float> [[X]]), !fpmath [[META3:![0-9]+]] +; IEEE-BADFREXP-NEXT: [[TMP56:%.*]] = extractelement <2 x float> [[X]], i64 0 +; IEEE-BADFREXP-NEXT: [[TMP57:%.*]] = extractelement <2 x float> [[X]], i64 1 +; IEEE-BADFREXP-NEXT: [[TMP58:%.*]] = fcmp olt float [[TMP56]], 0x3810000000000000 +; IEEE-BADFREXP-NEXT: [[TMP59:%.*]] = select i1 [[TMP58]], i32 32, i32 0 +; IEEE-BADFREXP-NEXT: [[TMP60:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP56]], i32 [[TMP59]]) +; IEEE-BADFREXP-NEXT: [[TMP61:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP60]]) +; IEEE-BADFREXP-NEXT: [[TMP62:%.*]] = select i1 [[TMP58]], i32 -16, i32 0 +; IEEE-BADFREXP-NEXT: [[TMP63:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP61]], i32 [[TMP62]]) +; IEEE-BADFREXP-NEXT: [[TMP64:%.*]] = fcmp olt float [[TMP57]], 0x3810000000000000 +; IEEE-BADFREXP-NEXT: [[TMP65:%.*]] = select i1 [[TMP64]], i32 32, i32 0 +; IEEE-BADFREXP-NEXT: [[TMP66:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP57]], i32 [[TMP65]]) +; IEEE-BADFREXP-NEXT: [[TMP67:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP66]]) +; IEEE-BADFREXP-NEXT: [[TMP68:%.*]] = select i1 [[TMP64]], i32 -16, i32 0 +; IEEE-BADFREXP-NEXT: [[TMP69:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP67]], i32 [[TMP68]]) +; IEEE-BADFREXP-NEXT: [[TMP70:%.*]] = insertelement <2 x float> poison, float [[TMP63]], i64 0 +; IEEE-BADFREXP-NEXT: [[SQRT_X_3ULP:%.*]] = insertelement <2 x float> [[TMP70]], float [[TMP69]], i64 1 ; IEEE-BADFREXP-NEXT: [[TMP39:%.*]] = extractelement <2 x float> [[SQRT_X_3ULP]], i64 0 ; IEEE-BADFREXP-NEXT: [[TMP40:%.*]] = extractelement <2 x float> [[SQRT_X_3ULP]], i64 1 ; IEEE-BADFREXP-NEXT: [[TMP41:%.*]] = extractelement <2 x float> [[X]], i64 0 @@ -2258,7 +2288,12 @@ define amdgpu_kernel void @rsq_f32_vector_fpmath(ptr addrspace(1) %out, <2 x flo ; DAZ-NEXT: [[SQRT_X_NO_MD:%.*]] = call contract <2 x float> @llvm.sqrt.v2f32(<2 x float> [[X]]) ; DAZ-NEXT: [[NO_MD:%.*]] = fdiv contract <2 x float> splat (float 1.000000e+00), [[SQRT_X_NO_MD]] ; DAZ-NEXT: store volatile <2 x float> [[NO_MD]], ptr addrspace(1) [[OUT]], align 4 -; DAZ-NEXT: [[SQRT_MD_1ULP:%.*]] = call contract <2 x float> @llvm.sqrt.v2f32(<2 x float> [[X]]), !fpmath [[META2:![0-9]+]] +; DAZ-NEXT: [[TMP39:%.*]] = extractelement <2 x float> [[X]], i64 0 +; DAZ-NEXT: [[TMP40:%.*]] = extractelement <2 x float> [[X]], i64 1 +; DAZ-NEXT: [[TMP41:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP39]]) +; DAZ-NEXT: [[TMP42:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP40]]) +; DAZ-NEXT: [[TMP43:%.*]] = insertelement <2 x float> poison, float [[TMP41]], i64 0 +; DAZ-NEXT: [[SQRT_MD_1ULP:%.*]] = insertelement <2 x float> [[TMP43]], float [[TMP42]], i64 1 ; DAZ-NEXT: [[TMP1:%.*]] = extractelement <2 x float> [[SQRT_MD_1ULP]], i64 0 ; DAZ-NEXT: [[TMP2:%.*]] = extractelement <2 x float> [[SQRT_MD_1ULP]], i64 1 ; DAZ-NEXT: [[TMP3:%.*]] = extractelement <2 x float> [[X]], i64 0 @@ -2276,7 +2311,9 @@ define amdgpu_kernel void @rsq_f32_vector_fpmath(ptr addrspace(1) %out, <2 x flo ; DAZ-NEXT: [[SQRT_MD_1ULP_UNDEF:%.*]] = insertelement <2 x float> [[TMP12]], float [[TMP11]], i64 1 ; DAZ-NEXT: [[TMP13:%.*]] = extractelement <2 x float> [[SQRT_MD_1ULP_UNDEF]], i64 0 ; DAZ-NEXT: [[TMP14:%.*]] = extractelement <2 x float> [[SQRT_MD_1ULP_UNDEF]], i64 1 -; DAZ-NEXT: [[TMP15:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP13]]) +; DAZ-NEXT: [[TMP44:%.*]] = extractelement <2 x float> [[X]], i64 0 +; DAZ-NEXT: [[TMP45:%.*]] = extractelement <2 x float> [[X]], i64 1 +; DAZ-NEXT: [[TMP15:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float [[TMP44]]) ; DAZ-NEXT: [[TMP16:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP14]]) ; DAZ-NEXT: [[TMP17:%.*]] = extractvalue { float, i32 } [[TMP16]], 0 ; DAZ-NEXT: [[TMP18:%.*]] = extractvalue { float, i32 } [[TMP16]], 1 @@ -2290,7 +2327,12 @@ define amdgpu_kernel void @rsq_f32_vector_fpmath(ptr addrspace(1) %out, <2 x flo ; DAZ-NEXT: [[TMP26:%.*]] = insertelement <2 x float> poison, float [[TMP15]], i64 0 ; DAZ-NEXT: [[MD_1ULP_UNDEF:%.*]] = insertelement <2 x float> [[TMP26]], float [[TMP25]], i64 1 ; DAZ-NEXT: store volatile <2 x float> [[MD_1ULP_UNDEF]], ptr addrspace(1) [[OUT]], align 4 -; DAZ-NEXT: [[SQRT_X_3ULP:%.*]] = call contract <2 x float> @llvm.sqrt.v2f32(<2 x float> [[X]]), !fpmath [[META3:![0-9]+]] +; DAZ-NEXT: [[TMP34:%.*]] = extractelement <2 x float> [[X]], i64 0 +; DAZ-NEXT: [[TMP35:%.*]] = extractelement <2 x float> [[X]], i64 1 +; DAZ-NEXT: [[TMP36:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP34]]) +; DAZ-NEXT: [[TMP37:%.*]] = call float @llvm.amdgcn.sqrt.f32(float [[TMP35]]) +; DAZ-NEXT: [[TMP38:%.*]] = insertelement <2 x float> poison, float [[TMP36]], i64 0 +; DAZ-NEXT: [[SQRT_X_3ULP:%.*]] = insertelement <2 x float> [[TMP38]], float [[TMP37]], i64 1 ; DAZ-NEXT: [[TMP27:%.*]] = extractelement <2 x float> [[SQRT_X_3ULP]], i64 0 ; DAZ-NEXT: [[TMP28:%.*]] = extractelement <2 x float> [[SQRT_X_3ULP]], i64 1 ; DAZ-NEXT: [[TMP29:%.*]] = extractelement <2 x float> [[X]], i64 0 @@ -3200,9 +3242,13 @@ define <4 x float> @rsq_f32_vector_mixed_constant_numerator(<4 x float> %arg) { ; DAZ-NEXT: [[TMP13:%.*]] = extractelement <4 x float> [[DENOM]], i64 1 ; DAZ-NEXT: [[TMP14:%.*]] = extractelement <4 x float> [[DENOM]], i64 2 ; DAZ-NEXT: [[TMP15:%.*]] = extractelement <4 x float> [[DENOM]], i64 3 -; DAZ-NEXT: [[TMP16:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP12]]) -; DAZ-NEXT: [[TMP17:%.*]] = fneg contract float [[TMP13]] -; DAZ-NEXT: [[TMP18:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP17]]) +; DAZ-NEXT: [[TMP42:%.*]] = extractelement <4 x float> [[ARG]], i64 0 +; DAZ-NEXT: [[TMP17:%.*]] = extractelement <4 x float> [[ARG]], i64 1 +; DAZ-NEXT: [[TMP43:%.*]] = extractelement <4 x float> [[ARG]], i64 2 +; DAZ-NEXT: [[TMP44:%.*]] = extractelement <4 x float> [[ARG]], i64 3 +; DAZ-NEXT: [[TMP16:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float [[TMP42]]) +; DAZ-NEXT: [[TMP45:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float [[TMP17]]) +; DAZ-NEXT: [[TMP18:%.*]] = fneg contract float [[TMP45]] ; DAZ-NEXT: [[TMP19:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP14]]) ; DAZ-NEXT: [[TMP20:%.*]] = extractvalue { float, i32 } [[TMP19]], 0 ; DAZ-NEXT: [[TMP21:%.*]] = extractvalue { float, i32 } [[TMP19]], 1 @@ -3675,9 +3721,13 @@ define <4 x float> @rsq_f32_vector_mixed_constant_numerator_arcp(<4 x float> %ar ; DAZ-NEXT: [[TMP13:%.*]] = extractelement <4 x float> [[DENOM]], i64 1 ; DAZ-NEXT: [[TMP14:%.*]] = extractelement <4 x float> [[DENOM]], i64 2 ; DAZ-NEXT: [[TMP15:%.*]] = extractelement <4 x float> [[DENOM]], i64 3 -; DAZ-NEXT: [[TMP16:%.*]] = call arcp contract float @llvm.amdgcn.rcp.f32(float [[TMP12]]) -; DAZ-NEXT: [[TMP17:%.*]] = fneg arcp contract float [[TMP13]] -; DAZ-NEXT: [[TMP18:%.*]] = call arcp contract float @llvm.amdgcn.rcp.f32(float [[TMP17]]) +; DAZ-NEXT: [[TMP26:%.*]] = extractelement <4 x float> [[ARG]], i64 0 +; DAZ-NEXT: [[TMP17:%.*]] = extractelement <4 x float> [[ARG]], i64 1 +; DAZ-NEXT: [[TMP27:%.*]] = extractelement <4 x float> [[ARG]], i64 2 +; DAZ-NEXT: [[TMP28:%.*]] = extractelement <4 x float> [[ARG]], i64 3 +; DAZ-NEXT: [[TMP16:%.*]] = call arcp contract float @llvm.amdgcn.rsq.f32(float [[TMP26]]) +; DAZ-NEXT: [[TMP29:%.*]] = call arcp contract float @llvm.amdgcn.rsq.f32(float [[TMP17]]) +; DAZ-NEXT: [[TMP18:%.*]] = fneg arcp contract float [[TMP29]] ; DAZ-NEXT: [[TMP19:%.*]] = call arcp contract float @llvm.amdgcn.rcp.f32(float [[TMP14]]) ; DAZ-NEXT: [[TMP20:%.*]] = fmul arcp contract float 4.000000e+00, [[TMP19]] ; DAZ-NEXT: [[TMP21:%.*]] = call arcp contract float @llvm.amdgcn.rcp.f32(float [[TMP15]]) @@ -3850,19 +3900,9 @@ define <4 x float> @rsq_f32_vector_const_denom(ptr addrspace(1) %out, <2 x float ; IEEE-GOODFREXP-NEXT: [[TMP9:%.*]] = extractelement <4 x float> [[SQRT]], i64 1 ; IEEE-GOODFREXP-NEXT: [[TMP10:%.*]] = extractelement <4 x float> [[SQRT]], i64 2 ; IEEE-GOODFREXP-NEXT: [[TMP11:%.*]] = extractelement <4 x float> [[SQRT]], i64 3 -; IEEE-GOODFREXP-NEXT: [[TMP12:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP8]]) -; IEEE-GOODFREXP-NEXT: [[TMP13:%.*]] = extractvalue { float, i32 } [[TMP12]], 0 -; IEEE-GOODFREXP-NEXT: [[TMP14:%.*]] = extractvalue { float, i32 } [[TMP12]], 1 -; IEEE-GOODFREXP-NEXT: [[TMP15:%.*]] = sub i32 0, [[TMP14]] -; IEEE-GOODFREXP-NEXT: [[TMP16:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP13]]) -; IEEE-GOODFREXP-NEXT: [[TMP17:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP16]], i32 [[TMP15]]) -; IEEE-GOODFREXP-NEXT: [[TMP18:%.*]] = fneg contract float [[TMP9]] -; IEEE-GOODFREXP-NEXT: [[TMP48:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP18]]) -; IEEE-GOODFREXP-NEXT: [[TMP49:%.*]] = extractvalue { float, i32 } [[TMP48]], 0 -; IEEE-GOODFREXP-NEXT: [[TMP50:%.*]] = extractvalue { float, i32 } [[TMP48]], 1 -; IEEE-GOODFREXP-NEXT: [[TMP22:%.*]] = sub i32 0, [[TMP50]] -; IEEE-GOODFREXP-NEXT: [[TMP51:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP49]]) -; IEEE-GOODFREXP-NEXT: [[TMP24:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP51]], i32 [[TMP22]]) +; IEEE-GOODFREXP-NEXT: [[TMP17:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float 4.000000e+00) +; IEEE-GOODFREXP-NEXT: [[TMP13:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float 2.000000e+00) +; IEEE-GOODFREXP-NEXT: [[TMP24:%.*]] = fneg contract float [[TMP13]] ; IEEE-GOODFREXP-NEXT: [[TMP29:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP10]]) ; IEEE-GOODFREXP-NEXT: [[TMP30:%.*]] = extractvalue { float, i32 } [[TMP29]], 0 ; IEEE-GOODFREXP-NEXT: [[TMP31:%.*]] = extractvalue { float, i32 } [[TMP29]], 1 @@ -3903,19 +3943,9 @@ define <4 x float> @rsq_f32_vector_const_denom(ptr addrspace(1) %out, <2 x float ; IEEE-BADFREXP-NEXT: [[TMP9:%.*]] = extractelement <4 x float> [[SQRT]], i64 1 ; IEEE-BADFREXP-NEXT: [[TMP10:%.*]] = extractelement <4 x float> [[SQRT]], i64 2 ; IEEE-BADFREXP-NEXT: [[TMP11:%.*]] = extractelement <4 x float> [[SQRT]], i64 3 -; IEEE-BADFREXP-NEXT: [[TMP12:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP8]]) -; IEEE-BADFREXP-NEXT: [[TMP13:%.*]] = extractvalue { float, i32 } [[TMP12]], 0 -; IEEE-BADFREXP-NEXT: [[TMP14:%.*]] = call i32 @llvm.amdgcn.frexp.exp.i32.f32(float [[TMP8]]) -; IEEE-BADFREXP-NEXT: [[TMP15:%.*]] = sub i32 0, [[TMP14]] -; IEEE-BADFREXP-NEXT: [[TMP16:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP13]]) -; IEEE-BADFREXP-NEXT: [[TMP17:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP16]], i32 [[TMP15]]) -; IEEE-BADFREXP-NEXT: [[TMP18:%.*]] = fneg contract float [[TMP9]] -; IEEE-BADFREXP-NEXT: [[TMP48:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP18]]) -; IEEE-BADFREXP-NEXT: [[TMP49:%.*]] = extractvalue { float, i32 } [[TMP48]], 0 -; IEEE-BADFREXP-NEXT: [[TMP21:%.*]] = call i32 @llvm.amdgcn.frexp.exp.i32.f32(float [[TMP18]]) -; IEEE-BADFREXP-NEXT: [[TMP22:%.*]] = sub i32 0, [[TMP21]] -; IEEE-BADFREXP-NEXT: [[TMP50:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP49]]) -; IEEE-BADFREXP-NEXT: [[TMP24:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP50]], i32 [[TMP22]]) +; IEEE-BADFREXP-NEXT: [[TMP17:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float 4.000000e+00) +; IEEE-BADFREXP-NEXT: [[TMP13:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float 2.000000e+00) +; IEEE-BADFREXP-NEXT: [[TMP24:%.*]] = fneg contract float [[TMP13]] ; IEEE-BADFREXP-NEXT: [[TMP29:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP10]]) ; IEEE-BADFREXP-NEXT: [[TMP30:%.*]] = extractvalue { float, i32 } [[TMP29]], 0 ; IEEE-BADFREXP-NEXT: [[TMP27:%.*]] = call i32 @llvm.amdgcn.frexp.exp.i32.f32(float [[TMP10]]) @@ -3956,9 +3986,9 @@ define <4 x float> @rsq_f32_vector_const_denom(ptr addrspace(1) %out, <2 x float ; DAZ-NEXT: [[TMP9:%.*]] = extractelement <4 x float> [[SQRT]], i64 1 ; DAZ-NEXT: [[TMP10:%.*]] = extractelement <4 x float> [[SQRT]], i64 2 ; DAZ-NEXT: [[TMP11:%.*]] = extractelement <4 x float> [[SQRT]], i64 3 -; DAZ-NEXT: [[TMP12:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP8]]) -; DAZ-NEXT: [[TMP13:%.*]] = fneg contract float [[TMP9]] -; DAZ-NEXT: [[TMP14:%.*]] = call contract float @llvm.amdgcn.rcp.f32(float [[TMP13]]) +; DAZ-NEXT: [[TMP12:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float 4.000000e+00) +; DAZ-NEXT: [[TMP13:%.*]] = call contract float @llvm.amdgcn.rsq.f32(float 2.000000e+00) +; DAZ-NEXT: [[TMP14:%.*]] = fneg contract float [[TMP13]] ; DAZ-NEXT: [[TMP15:%.*]] = call { float, i32 } @llvm.frexp.f32.i32(float [[TMP10]]) ; DAZ-NEXT: [[TMP16:%.*]] = extractvalue { float, i32 } [[TMP15]], 0 ; DAZ-NEXT: [[TMP17:%.*]] = extractvalue { float, i32 } [[TMP15]], 1 diff --git a/llvm/test/CodeGen/AMDGPU/coalescer-avoid-coalesce-class-with-no-registers.ll b/llvm/test/CodeGen/AMDGPU/coalescer-avoid-coalesce-class-with-no-registers.ll new file mode 100644 index 0000000..f466513 --- /dev/null +++ b/llvm/test/CodeGen/AMDGPU/coalescer-avoid-coalesce-class-with-no-registers.ll @@ -0,0 +1,27 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6 +; RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 < %s | FileCheck %s + +; Make sure the coalescer doesn't introduce any uses of +; vreg_1024. None are available to allocate with the register budget +; of this function. + +define void @no_introduce_vreg_1024() #0 { +; CHECK-LABEL: no_introduce_vreg_1024: +; CHECK: ; %bb.0: +; CHECK-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) +; CHECK-NEXT: ;;#ASMSTART +; CHECK-NEXT: ; def v[0:7] +; CHECK-NEXT: ;;#ASMEND +; CHECK-NEXT: v_mov_b32_e32 v9, v0 +; CHECK-NEXT: ;;#ASMSTART +; CHECK-NEXT: ; use v[0:15] +; CHECK-NEXT: ;;#ASMEND +; CHECK-NEXT: s_setpc_b64 s[30:31] + %tuple = call <8 x i32> asm sideeffect "; def $0","=v"() + %sub0 = extractelement <8 x i32> %tuple, i32 0 + %insert = insertelement <16 x i32> poison, i32 %sub0, i32 9 + call void asm sideeffect "; use $0","v"(<16 x i32> %insert) + ret void +} + +attributes #0 = { nounwind "amdgpu-waves-per-eu"="10,10" } diff --git a/llvm/test/CodeGen/AMDGPU/coalescer-avoid-coalesce-class-with-no-registers.mir b/llvm/test/CodeGen/AMDGPU/coalescer-avoid-coalesce-class-with-no-registers.mir new file mode 100644 index 0000000..1f414eb --- /dev/null +++ b/llvm/test/CodeGen/AMDGPU/coalescer-avoid-coalesce-class-with-no-registers.mir @@ -0,0 +1,34 @@ +# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py UTC_ARGS: --version 6 +# RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 -run-pass=register-coalescer -o - %s | FileCheck %s + +# The register budget for this function does not permit using 1024-bit +# registers. The coalescer should not introduce a 1024-bit virtual +# register which will fail to allocate. + +--- | + define void @no_introduce_vreg_1024() #0 { + ret void + } + + attributes #0 = { "amdgpu-waves-per-eu"="10,10" } +... +--- +name: no_introduce_vreg_1024 +tracksRegLiveness: true +machineFunctionInfo: + occupancy: 10 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + + ; CHECK-LABEL: name: no_introduce_vreg_1024 + ; CHECK: liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK-NEXT: {{ $}} + ; CHECK-NEXT: [[COPY:%[0-9]+]]:vreg_256 = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK-NEXT: undef [[COPY1:%[0-9]+]].sub9:vreg_512 = COPY [[COPY]].sub0 + ; CHECK-NEXT: SI_RETURN implicit [[COPY1]] + %0:vreg_256 = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + undef %1.sub9:vreg_512 = COPY %0.sub0 + SI_RETURN implicit %1 + +... diff --git a/llvm/test/CodeGen/AMDGPU/fdiv_flags.f32.ll b/llvm/test/CodeGen/AMDGPU/fdiv_flags.f32.ll index 3983655..38239c5 100644 --- a/llvm/test/CodeGen/AMDGPU/fdiv_flags.f32.ll +++ b/llvm/test/CodeGen/AMDGPU/fdiv_flags.f32.ll @@ -1634,29 +1634,18 @@ define float @v_recip_sqrt_f32_ulp25_contract(float %x) { ; IR-IEEE-SDAG-LABEL: v_recip_sqrt_f32_ulp25_contract: ; IR-IEEE-SDAG: ; %bb.0: ; IR-IEEE-SDAG-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; IR-IEEE-SDAG-NEXT: s_mov_b32 s4, 0xf800000 -; IR-IEEE-SDAG-NEXT: v_mul_f32_e32 v1, 0x4f800000, v0 +; IR-IEEE-SDAG-NEXT: s_mov_b32 s4, 0x800000 ; IR-IEEE-SDAG-NEXT: v_cmp_gt_f32_e32 vcc, s4, v0 -; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc -; IR-IEEE-SDAG-NEXT: v_sqrt_f32_e32 v1, v0 -; IR-IEEE-SDAG-NEXT: v_add_i32_e64 v2, s[4:5], -1, v1 -; IR-IEEE-SDAG-NEXT: v_fma_f32 v3, -v2, v1, v0 -; IR-IEEE-SDAG-NEXT: v_cmp_ge_f32_e64 s[4:5], 0, v3 -; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e64 v2, v1, v2, s[4:5] -; IR-IEEE-SDAG-NEXT: v_add_i32_e64 v3, s[4:5], 1, v1 -; IR-IEEE-SDAG-NEXT: v_fma_f32 v1, -v3, v1, v0 -; IR-IEEE-SDAG-NEXT: v_cmp_lt_f32_e64 s[4:5], 0, v1 -; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e64 v1, v2, v3, s[4:5] -; IR-IEEE-SDAG-NEXT: v_mul_f32_e32 v2, 0x37800000, v1 -; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e32 v1, v1, v2, vcc -; IR-IEEE-SDAG-NEXT: v_mov_b32_e32 v2, 0x260 -; IR-IEEE-SDAG-NEXT: v_cmp_class_f32_e32 vcc, v0, v2 -; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e32 v0, v1, v0, vcc +; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e64 v1, 0, 32, vcc +; IR-IEEE-SDAG-NEXT: v_ldexp_f32_e32 v0, v0, v1 +; IR-IEEE-SDAG-NEXT: v_sqrt_f32_e32 v0, v0 +; IR-IEEE-SDAG-NEXT: v_cndmask_b32_e64 v1, 0, -16, vcc +; IR-IEEE-SDAG-NEXT: v_ldexp_f32_e32 v0, v0, v1 ; IR-IEEE-SDAG-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 ; IR-IEEE-SDAG-NEXT: v_rcp_f32_e32 v2, v1 -; IR-IEEE-SDAG-NEXT: v_fma_f32 v3, -v1, v2, 1.0 -; IR-IEEE-SDAG-NEXT: v_fma_f32 v2, v3, v2, v2 ; IR-IEEE-SDAG-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; IR-IEEE-SDAG-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; IR-IEEE-SDAG-NEXT: v_fma_f32 v2, v4, v2, v2 ; IR-IEEE-SDAG-NEXT: v_mul_f32_e32 v4, v3, v2 ; IR-IEEE-SDAG-NEXT: v_fma_f32 v5, -v1, v4, v3 ; IR-IEEE-SDAG-NEXT: v_fma_f32 v4, v5, v2, v4 @@ -1668,24 +1657,14 @@ define float @v_recip_sqrt_f32_ulp25_contract(float %x) { ; IR-IEEE-GISEL-LABEL: v_recip_sqrt_f32_ulp25_contract: ; IR-IEEE-GISEL: ; %bb.0: ; IR-IEEE-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; IR-IEEE-GISEL-NEXT: v_mov_b32_e32 v1, 0xf800000 -; IR-IEEE-GISEL-NEXT: v_mul_f32_e32 v2, 0x4f800000, v0 +; IR-IEEE-GISEL-NEXT: v_mov_b32_e32 v1, 0x800000 ; IR-IEEE-GISEL-NEXT: v_cmp_lt_f32_e32 vcc, v0, v1 -; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e32 v0, v0, v2, vcc -; IR-IEEE-GISEL-NEXT: v_sqrt_f32_e32 v1, v0 -; IR-IEEE-GISEL-NEXT: v_add_i32_e64 v2, s[4:5], -1, v1 -; IR-IEEE-GISEL-NEXT: v_fma_f32 v3, -v2, v1, v0 -; IR-IEEE-GISEL-NEXT: v_add_i32_e64 v4, s[4:5], 1, v1 -; IR-IEEE-GISEL-NEXT: v_fma_f32 v5, -v4, v1, v0 -; IR-IEEE-GISEL-NEXT: v_cmp_ge_f32_e64 s[4:5], 0, v3 -; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e64 v1, v1, v2, s[4:5] -; IR-IEEE-GISEL-NEXT: v_cmp_lt_f32_e64 s[4:5], 0, v5 -; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e64 v1, v1, v4, s[4:5] -; IR-IEEE-GISEL-NEXT: v_mul_f32_e32 v2, 0x37800000, v1 -; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e32 v1, v1, v2, vcc -; IR-IEEE-GISEL-NEXT: v_mov_b32_e32 v2, 0x260 -; IR-IEEE-GISEL-NEXT: v_cmp_class_f32_e32 vcc, v0, v2 -; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e32 v0, v1, v0, vcc +; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc +; IR-IEEE-GISEL-NEXT: v_lshlrev_b32_e32 v1, 5, v1 +; IR-IEEE-GISEL-NEXT: v_ldexp_f32_e32 v0, v0, v1 +; IR-IEEE-GISEL-NEXT: v_sqrt_f32_e32 v0, v0 +; IR-IEEE-GISEL-NEXT: v_cndmask_b32_e64 v1, 0, -16, vcc +; IR-IEEE-GISEL-NEXT: v_ldexp_f32_e32 v0, v0, v1 ; IR-IEEE-GISEL-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 ; IR-IEEE-GISEL-NEXT: v_rcp_f32_e32 v2, v1 ; IR-IEEE-GISEL-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 @@ -1705,75 +1684,24 @@ define float @v_recip_sqrt_f32_ulp25_contract(float %x) { ; CODEGEN-DAZ-NEXT: v_rsq_f32_e32 v0, v0 ; CODEGEN-DAZ-NEXT: s_setpc_b64 s[30:31] ; -; IR-DAZ-SDAG-LABEL: v_recip_sqrt_f32_ulp25_contract: -; IR-DAZ-SDAG: ; %bb.0: -; IR-DAZ-SDAG-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; IR-DAZ-SDAG-NEXT: s_mov_b32 s4, 0xf800000 -; IR-DAZ-SDAG-NEXT: v_mul_f32_e32 v1, 0x4f800000, v0 -; IR-DAZ-SDAG-NEXT: v_cmp_gt_f32_e32 vcc, s4, v0 -; IR-DAZ-SDAG-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc -; IR-DAZ-SDAG-NEXT: v_rsq_f32_e32 v1, v0 -; IR-DAZ-SDAG-NEXT: v_mul_f32_e32 v2, v0, v1 -; IR-DAZ-SDAG-NEXT: v_mul_f32_e32 v1, 0.5, v1 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v3, -v1, v2, 0.5 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v2, v2, v3, v2 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v4, -v2, v2, v0 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v1, v1, v3, v1 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v1, v4, v1, v2 -; IR-DAZ-SDAG-NEXT: v_mul_f32_e32 v2, 0x37800000, v1 -; IR-DAZ-SDAG-NEXT: v_cndmask_b32_e32 v1, v1, v2, vcc -; IR-DAZ-SDAG-NEXT: v_mov_b32_e32 v2, 0x260 -; IR-DAZ-SDAG-NEXT: v_cmp_class_f32_e32 vcc, v0, v2 -; IR-DAZ-SDAG-NEXT: v_cndmask_b32_e32 v0, v1, v0, vcc -; IR-DAZ-SDAG-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 -; IR-DAZ-SDAG-NEXT: v_rcp_f32_e32 v2, v1 -; IR-DAZ-SDAG-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 -; IR-DAZ-SDAG-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v4, -v1, v2, 1.0 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v2, v4, v2, v2 -; IR-DAZ-SDAG-NEXT: v_mul_f32_e32 v4, v3, v2 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v5, -v1, v4, v3 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v4, v5, v2, v4 -; IR-DAZ-SDAG-NEXT: v_fma_f32 v1, -v1, v4, v3 -; IR-DAZ-SDAG-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; IR-DAZ-SDAG-NEXT: v_div_fmas_f32 v1, v1, v2, v4 -; IR-DAZ-SDAG-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 -; IR-DAZ-SDAG-NEXT: s_setpc_b64 s[30:31] -; -; IR-DAZ-GISEL-LABEL: v_recip_sqrt_f32_ulp25_contract: -; IR-DAZ-GISEL: ; %bb.0: -; IR-DAZ-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; IR-DAZ-GISEL-NEXT: v_mov_b32_e32 v1, 0xf800000 -; IR-DAZ-GISEL-NEXT: v_mul_f32_e32 v2, 0x4f800000, v0 -; IR-DAZ-GISEL-NEXT: v_cmp_lt_f32_e32 vcc, v0, v1 -; IR-DAZ-GISEL-NEXT: v_cndmask_b32_e32 v0, v0, v2, vcc -; IR-DAZ-GISEL-NEXT: v_rsq_f32_e32 v1, v0 -; IR-DAZ-GISEL-NEXT: v_mul_f32_e32 v2, v0, v1 -; IR-DAZ-GISEL-NEXT: v_mul_f32_e32 v1, 0.5, v1 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v3, -v1, v2, 0.5 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v2, v2, v3, v2 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v1, v1, v3, v1 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v3, -v2, v2, v0 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v1, v3, v1, v2 -; IR-DAZ-GISEL-NEXT: v_mul_f32_e32 v2, 0x37800000, v1 -; IR-DAZ-GISEL-NEXT: v_cndmask_b32_e32 v1, v1, v2, vcc -; IR-DAZ-GISEL-NEXT: v_mov_b32_e32 v2, 0x260 -; IR-DAZ-GISEL-NEXT: v_cmp_class_f32_e32 vcc, v0, v2 -; IR-DAZ-GISEL-NEXT: v_cndmask_b32_e32 v0, v1, v0, vcc -; IR-DAZ-GISEL-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 -; IR-DAZ-GISEL-NEXT: v_rcp_f32_e32 v2, v1 -; IR-DAZ-GISEL-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 -; IR-DAZ-GISEL-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v4, -v1, v2, 1.0 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v2, v4, v2, v2 -; IR-DAZ-GISEL-NEXT: v_mul_f32_e32 v4, v3, v2 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v5, -v1, v4, v3 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v4, v5, v2, v4 -; IR-DAZ-GISEL-NEXT: v_fma_f32 v1, -v1, v4, v3 -; IR-DAZ-GISEL-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 -; IR-DAZ-GISEL-NEXT: v_div_fmas_f32 v1, v1, v2, v4 -; IR-DAZ-GISEL-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 -; IR-DAZ-GISEL-NEXT: s_setpc_b64 s[30:31] +; IR-DAZ-LABEL: v_recip_sqrt_f32_ulp25_contract: +; IR-DAZ: ; %bb.0: +; IR-DAZ-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) +; IR-DAZ-NEXT: v_sqrt_f32_e32 v0, v0 +; IR-DAZ-NEXT: v_div_scale_f32 v1, s[4:5], v0, v0, 1.0 +; IR-DAZ-NEXT: v_rcp_f32_e32 v2, v1 +; IR-DAZ-NEXT: v_div_scale_f32 v3, vcc, 1.0, v0, 1.0 +; IR-DAZ-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 3 +; IR-DAZ-NEXT: v_fma_f32 v4, -v1, v2, 1.0 +; IR-DAZ-NEXT: v_fma_f32 v2, v4, v2, v2 +; IR-DAZ-NEXT: v_mul_f32_e32 v4, v3, v2 +; IR-DAZ-NEXT: v_fma_f32 v5, -v1, v4, v3 +; IR-DAZ-NEXT: v_fma_f32 v4, v5, v2, v4 +; IR-DAZ-NEXT: v_fma_f32 v1, -v1, v4, v3 +; IR-DAZ-NEXT: s_setreg_imm32_b32 hwreg(HW_REG_MODE, 4, 2), 0 +; IR-DAZ-NEXT: v_div_fmas_f32 v1, v1, v2, v4 +; IR-DAZ-NEXT: v_div_fixup_f32 v0, v1, v0, 1.0 +; IR-DAZ-NEXT: s_setpc_b64 s[30:31] %sqrt = call contract float @llvm.sqrt.f32(float %x), !fpmath !0 %fdiv = fdiv contract float 1.0, %sqrt, !fpmath !0 ret float %fdiv diff --git a/llvm/test/CodeGen/AMDGPU/fmed3.ll b/llvm/test/CodeGen/AMDGPU/fmed3.ll index 9233f80..9e15225 100644 --- a/llvm/test/CodeGen/AMDGPU/fmed3.ll +++ b/llvm/test/CodeGen/AMDGPU/fmed3.ll @@ -7464,18 +7464,15 @@ define amdgpu_kernel void @v_test_nnan_input_fmed3_r_i_i_f16(ptr addrspace(1) %o ; SI-GISEL-NEXT: s_waitcnt lgkmcnt(0) ; SI-GISEL-NEXT: s_mov_b64 s[4:5], s[2:3] ; SI-GISEL-NEXT: buffer_load_ushort v2, v[0:1], s[4:7], 0 addr64 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, 1.0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v4, 2.0 ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 -; SI-GISEL-NEXT: v_add_f32_e32 v2, v2, v3 +; SI-GISEL-NEXT: v_add_f32_e32 v2, 1.0, v2 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v2, v2 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 -; SI-GISEL-NEXT: v_max_f32_e32 v2, v2, v4 +; SI-GISEL-NEXT: v_max_f32_e32 v2, 2.0, v2 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v2, v2 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, 4.0 -; SI-GISEL-NEXT: v_min_f32_e32 v2, v2, v3 +; SI-GISEL-NEXT: v_min_f32_e32 v2, 4.0, v2 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v2, v2 ; SI-GISEL-NEXT: s_mov_b64 s[2:3], s[6:7] ; SI-GISEL-NEXT: buffer_store_short v2, v[0:1], s[0:3], 0 addr64 @@ -7639,27 +7636,24 @@ define amdgpu_kernel void @v_nnan_inputs_med3_f16_pat0(ptr addrspace(1) %out, pt ; SI-GISEL-NEXT: v_mov_b32_e32 v1, 0 ; SI-GISEL-NEXT: s_mov_b32 s10, 0 ; SI-GISEL-NEXT: s_mov_b32 s11, 0xf000 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, 1.0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, 2.0 ; SI-GISEL-NEXT: s_waitcnt lgkmcnt(0) ; SI-GISEL-NEXT: s_mov_b64 s[8:9], s[2:3] -; SI-GISEL-NEXT: buffer_load_ushort v4, v[0:1], s[8:11], 0 addr64 glc +; SI-GISEL-NEXT: buffer_load_ushort v2, v[0:1], s[8:11], 0 addr64 glc ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v5, 4.0 ; SI-GISEL-NEXT: s_mov_b64 s[8:9], s[4:5] -; SI-GISEL-NEXT: buffer_load_ushort v6, v[0:1], s[8:11], 0 addr64 glc +; SI-GISEL-NEXT: buffer_load_ushort v3, v[0:1], s[8:11], 0 addr64 glc ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) ; SI-GISEL-NEXT: s_mov_b64 s[8:9], s[6:7] -; SI-GISEL-NEXT: buffer_load_ushort v7, v[0:1], s[8:11], 0 addr64 glc +; SI-GISEL-NEXT: buffer_load_ushort v4, v[0:1], s[8:11], 0 addr64 glc ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v4, v4 -; SI-GISEL-NEXT: v_add_f32_e32 v2, v4, v2 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v4, v6 +; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 +; SI-GISEL-NEXT: v_add_f32_e32 v2, 1.0, v2 +; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, v3 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v2, v2 -; SI-GISEL-NEXT: v_add_f32_e32 v3, v4, v3 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v4, v7 +; SI-GISEL-NEXT: v_add_f32_e32 v3, 2.0, v3 +; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v4, v4 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v3, v3 -; SI-GISEL-NEXT: v_add_f32_e32 v4, v4, v5 +; SI-GISEL-NEXT: v_add_f32_e32 v4, 4.0, v4 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v4, v4 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, v3 @@ -8712,12 +8706,10 @@ define half @v_test_fmed3_r_i_i_f16_minimumnum_maximumnum(half %a) #1 { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, 2.0 -; SI-GISEL-NEXT: v_max_f32_e32 v0, v0, v1 +; SI-GISEL-NEXT: v_max_f32_e32 v0, 2.0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, 4.0 -; SI-GISEL-NEXT: v_min_f32_e32 v0, v0, v1 +; SI-GISEL-NEXT: v_min_f32_e32 v0, 4.0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -8796,17 +8788,15 @@ define <2 x half> @v_test_fmed3_r_i_i_v2f16_minimumnum_maximumnum(<2 x half> %a) ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, 2.0 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, v1 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, 4.0 -; SI-GISEL-NEXT: v_max_f32_e32 v0, v0, v2 -; SI-GISEL-NEXT: v_max_f32_e32 v1, v1, v2 +; SI-GISEL-NEXT: v_max_f32_e32 v0, 2.0, v0 +; SI-GISEL-NEXT: v_max_f32_e32 v1, 2.0, v1 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, v1 -; SI-GISEL-NEXT: v_min_f32_e32 v0, v0, v3 -; SI-GISEL-NEXT: v_min_f32_e32 v1, v1, v3 +; SI-GISEL-NEXT: v_min_f32_e32 v0, 4.0, v0 +; SI-GISEL-NEXT: v_min_f32_e32 v1, 4.0, v1 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v1, v1 ; SI-GISEL-NEXT: s_setpc_b64 s[30:31] diff --git a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.smfmac.gfx950.ll b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.smfmac.gfx950.ll index ee11b92..0c1448a 100644 --- a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.smfmac.gfx950.ll +++ b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.smfmac.gfx950.ll @@ -44,23 +44,23 @@ define amdgpu_kernel void @test_smfmac_f32_16x16x64_f16__vgpr(ptr addrspace(1) % ; GISEL-NEXT: v_and_b32_e32 v0, 0x3ff, v0 ; GISEL-NEXT: v_lshlrev_b32_e32 v0, 4, v0 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: global_load_dwordx4 v[14:17], v0, s[6:7] +; GISEL-NEXT: global_load_dwordx4 v[8:11], v0, s[6:7] ; GISEL-NEXT: s_load_dwordx8 s[8:15], s[4:5], 0x44 ; GISEL-NEXT: s_load_dword s16, s[4:5], 0x64 -; GISEL-NEXT: v_mov_b64_e32 v[10:11], s[2:3] -; GISEL-NEXT: v_mov_b64_e32 v[8:9], s[0:1] +; GISEL-NEXT: v_mov_b64_e32 v[14:15], s[2:3] +; GISEL-NEXT: v_mov_b64_e32 v[12:13], s[0:1] ; GISEL-NEXT: s_waitcnt lgkmcnt(0) ; GISEL-NEXT: v_mov_b64_e32 v[0:1], s[8:9] ; GISEL-NEXT: v_mov_b64_e32 v[2:3], s[10:11] ; GISEL-NEXT: v_mov_b64_e32 v[4:5], s[12:13] ; GISEL-NEXT: v_mov_b64_e32 v[6:7], s[14:15] -; GISEL-NEXT: v_mov_b32_e32 v12, s16 +; GISEL-NEXT: v_mov_b32_e32 v16, s16 ; GISEL-NEXT: s_waitcnt vmcnt(0) ; GISEL-NEXT: s_nop 0 -; GISEL-NEXT: v_smfmac_f32_16x16x64_f16 v[14:17], v[8:11], v[0:7], v12 cbsz:1 abid:2 +; GISEL-NEXT: v_smfmac_f32_16x16x64_f16 v[8:11], v[12:15], v[0:7], v16 cbsz:1 abid:2 ; GISEL-NEXT: v_mov_b32_e32 v0, 0 ; GISEL-NEXT: s_nop 6 -; GISEL-NEXT: global_store_dwordx4 v0, v[14:17], s[6:7] +; GISEL-NEXT: global_store_dwordx4 v0, v[8:11], s[6:7] ; GISEL-NEXT: s_endpgm bb: %id = call i32 @llvm.amdgcn.workitem.id.x() @@ -834,24 +834,24 @@ define amdgpu_kernel void @test_smfmac_i32_16x16x128_i8__vgpr(ptr addrspace(1) % ; GISEL-NEXT: v_and_b32_e32 v0, 0x3ff, v0 ; GISEL-NEXT: v_lshlrev_b32_e32 v0, 4, v0 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: global_load_dwordx4 v[14:17], v0, s[0:1] +; GISEL-NEXT: global_load_dwordx4 v[8:11], v0, s[0:1] ; GISEL-NEXT: s_load_dwordx8 s[8:15], s[4:5], 0x34 ; GISEL-NEXT: s_load_dwordx4 s[16:19], s[4:5], 0x54 ; GISEL-NEXT: s_load_dword s2, s[4:5], 0x64 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: v_mov_b64_e32 v[8:9], s[8:9] -; GISEL-NEXT: v_mov_b64_e32 v[10:11], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[14:15], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[12:13], s[8:9] ; GISEL-NEXT: v_mov_b64_e32 v[0:1], s[12:13] ; GISEL-NEXT: v_mov_b64_e32 v[2:3], s[14:15] ; GISEL-NEXT: v_mov_b64_e32 v[4:5], s[16:17] ; GISEL-NEXT: v_mov_b64_e32 v[6:7], s[18:19] -; GISEL-NEXT: v_mov_b32_e32 v12, s2 +; GISEL-NEXT: v_mov_b32_e32 v16, s2 ; GISEL-NEXT: s_waitcnt vmcnt(0) ; GISEL-NEXT: s_nop 0 -; GISEL-NEXT: v_smfmac_i32_16x16x128_i8 v[14:17], v[8:11], v[0:7], v12 cbsz:1 abid:2 +; GISEL-NEXT: v_smfmac_i32_16x16x128_i8 v[8:11], v[12:15], v[0:7], v16 cbsz:1 abid:2 ; GISEL-NEXT: v_mov_b32_e32 v0, 0 ; GISEL-NEXT: s_nop 6 -; GISEL-NEXT: global_store_dwordx4 v0, v[14:17], s[0:1] +; GISEL-NEXT: global_store_dwordx4 v0, v[8:11], s[0:1] ; GISEL-NEXT: s_endpgm bb: %id = call i32 @llvm.amdgcn.workitem.id.x() @@ -1349,24 +1349,24 @@ define amdgpu_kernel void @test_smfmac_f32_16x16x128_bf8_bf8__vgpr(ptr addrspace ; GISEL-NEXT: v_and_b32_e32 v0, 0x3ff, v0 ; GISEL-NEXT: v_lshlrev_b32_e32 v0, 4, v0 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: global_load_dwordx4 v[14:17], v0, s[0:1] +; GISEL-NEXT: global_load_dwordx4 v[8:11], v0, s[0:1] ; GISEL-NEXT: s_load_dwordx8 s[8:15], s[4:5], 0x34 ; GISEL-NEXT: s_load_dwordx4 s[16:19], s[4:5], 0x54 ; GISEL-NEXT: s_load_dword s2, s[4:5], 0x64 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: v_mov_b64_e32 v[8:9], s[8:9] -; GISEL-NEXT: v_mov_b64_e32 v[10:11], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[14:15], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[12:13], s[8:9] ; GISEL-NEXT: v_mov_b64_e32 v[0:1], s[12:13] ; GISEL-NEXT: v_mov_b64_e32 v[2:3], s[14:15] ; GISEL-NEXT: v_mov_b64_e32 v[4:5], s[16:17] ; GISEL-NEXT: v_mov_b64_e32 v[6:7], s[18:19] -; GISEL-NEXT: v_mov_b32_e32 v12, s2 +; GISEL-NEXT: v_mov_b32_e32 v16, s2 ; GISEL-NEXT: s_waitcnt vmcnt(0) ; GISEL-NEXT: s_nop 0 -; GISEL-NEXT: v_smfmac_f32_16x16x128_bf8_bf8 v[14:17], v[8:11], v[0:7], v12 cbsz:1 abid:2 +; GISEL-NEXT: v_smfmac_f32_16x16x128_bf8_bf8 v[8:11], v[12:15], v[0:7], v16 cbsz:1 abid:2 ; GISEL-NEXT: v_mov_b32_e32 v0, 0 ; GISEL-NEXT: s_nop 6 -; GISEL-NEXT: global_store_dwordx4 v0, v[14:17], s[0:1] +; GISEL-NEXT: global_store_dwordx4 v0, v[8:11], s[0:1] ; GISEL-NEXT: s_endpgm bb: %id = call i32 @llvm.amdgcn.workitem.id.x() @@ -1513,24 +1513,24 @@ define amdgpu_kernel void @test_smfmac_f32_16x16x128_bf8_fp8__vgpr(ptr addrspace ; GISEL-NEXT: v_and_b32_e32 v0, 0x3ff, v0 ; GISEL-NEXT: v_lshlrev_b32_e32 v0, 4, v0 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: global_load_dwordx4 v[14:17], v0, s[0:1] +; GISEL-NEXT: global_load_dwordx4 v[8:11], v0, s[0:1] ; GISEL-NEXT: s_load_dwordx8 s[8:15], s[4:5], 0x34 ; GISEL-NEXT: s_load_dwordx4 s[16:19], s[4:5], 0x54 ; GISEL-NEXT: s_load_dword s2, s[4:5], 0x64 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: v_mov_b64_e32 v[8:9], s[8:9] -; GISEL-NEXT: v_mov_b64_e32 v[10:11], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[14:15], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[12:13], s[8:9] ; GISEL-NEXT: v_mov_b64_e32 v[0:1], s[12:13] ; GISEL-NEXT: v_mov_b64_e32 v[2:3], s[14:15] ; GISEL-NEXT: v_mov_b64_e32 v[4:5], s[16:17] ; GISEL-NEXT: v_mov_b64_e32 v[6:7], s[18:19] -; GISEL-NEXT: v_mov_b32_e32 v12, s2 +; GISEL-NEXT: v_mov_b32_e32 v16, s2 ; GISEL-NEXT: s_waitcnt vmcnt(0) ; GISEL-NEXT: s_nop 0 -; GISEL-NEXT: v_smfmac_f32_16x16x128_bf8_fp8 v[14:17], v[8:11], v[0:7], v12 cbsz:1 abid:2 +; GISEL-NEXT: v_smfmac_f32_16x16x128_bf8_fp8 v[8:11], v[12:15], v[0:7], v16 cbsz:1 abid:2 ; GISEL-NEXT: v_mov_b32_e32 v0, 0 ; GISEL-NEXT: s_nop 6 -; GISEL-NEXT: global_store_dwordx4 v0, v[14:17], s[0:1] +; GISEL-NEXT: global_store_dwordx4 v0, v[8:11], s[0:1] ; GISEL-NEXT: s_endpgm bb: %id = call i32 @llvm.amdgcn.workitem.id.x() @@ -1677,24 +1677,24 @@ define amdgpu_kernel void @test_smfmac_f32_16x16x128_fp8_bf8__vgpr(ptr addrspace ; GISEL-NEXT: v_and_b32_e32 v0, 0x3ff, v0 ; GISEL-NEXT: v_lshlrev_b32_e32 v0, 4, v0 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: global_load_dwordx4 v[14:17], v0, s[0:1] +; GISEL-NEXT: global_load_dwordx4 v[8:11], v0, s[0:1] ; GISEL-NEXT: s_load_dwordx8 s[8:15], s[4:5], 0x34 ; GISEL-NEXT: s_load_dwordx4 s[16:19], s[4:5], 0x54 ; GISEL-NEXT: s_load_dword s2, s[4:5], 0x64 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: v_mov_b64_e32 v[8:9], s[8:9] -; GISEL-NEXT: v_mov_b64_e32 v[10:11], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[14:15], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[12:13], s[8:9] ; GISEL-NEXT: v_mov_b64_e32 v[0:1], s[12:13] ; GISEL-NEXT: v_mov_b64_e32 v[2:3], s[14:15] ; GISEL-NEXT: v_mov_b64_e32 v[4:5], s[16:17] ; GISEL-NEXT: v_mov_b64_e32 v[6:7], s[18:19] -; GISEL-NEXT: v_mov_b32_e32 v12, s2 +; GISEL-NEXT: v_mov_b32_e32 v16, s2 ; GISEL-NEXT: s_waitcnt vmcnt(0) ; GISEL-NEXT: s_nop 0 -; GISEL-NEXT: v_smfmac_f32_16x16x128_fp8_bf8 v[14:17], v[8:11], v[0:7], v12 cbsz:1 abid:2 +; GISEL-NEXT: v_smfmac_f32_16x16x128_fp8_bf8 v[8:11], v[12:15], v[0:7], v16 cbsz:1 abid:2 ; GISEL-NEXT: v_mov_b32_e32 v0, 0 ; GISEL-NEXT: s_nop 6 -; GISEL-NEXT: global_store_dwordx4 v0, v[14:17], s[0:1] +; GISEL-NEXT: global_store_dwordx4 v0, v[8:11], s[0:1] ; GISEL-NEXT: s_endpgm bb: %id = call i32 @llvm.amdgcn.workitem.id.x() @@ -1841,24 +1841,24 @@ define amdgpu_kernel void @test_smfmac_f32_16x16x128_fp8_fp8__vgpr(ptr addrspace ; GISEL-NEXT: v_and_b32_e32 v0, 0x3ff, v0 ; GISEL-NEXT: v_lshlrev_b32_e32 v0, 4, v0 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: global_load_dwordx4 v[14:17], v0, s[0:1] +; GISEL-NEXT: global_load_dwordx4 v[8:11], v0, s[0:1] ; GISEL-NEXT: s_load_dwordx8 s[8:15], s[4:5], 0x34 ; GISEL-NEXT: s_load_dwordx4 s[16:19], s[4:5], 0x54 ; GISEL-NEXT: s_load_dword s2, s[4:5], 0x64 ; GISEL-NEXT: s_waitcnt lgkmcnt(0) -; GISEL-NEXT: v_mov_b64_e32 v[8:9], s[8:9] -; GISEL-NEXT: v_mov_b64_e32 v[10:11], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[14:15], s[10:11] +; GISEL-NEXT: v_mov_b64_e32 v[12:13], s[8:9] ; GISEL-NEXT: v_mov_b64_e32 v[0:1], s[12:13] ; GISEL-NEXT: v_mov_b64_e32 v[2:3], s[14:15] ; GISEL-NEXT: v_mov_b64_e32 v[4:5], s[16:17] ; GISEL-NEXT: v_mov_b64_e32 v[6:7], s[18:19] -; GISEL-NEXT: v_mov_b32_e32 v12, s2 +; GISEL-NEXT: v_mov_b32_e32 v16, s2 ; GISEL-NEXT: s_waitcnt vmcnt(0) ; GISEL-NEXT: s_nop 0 -; GISEL-NEXT: v_smfmac_f32_16x16x128_fp8_fp8 v[14:17], v[8:11], v[0:7], v12 cbsz:1 abid:2 +; GISEL-NEXT: v_smfmac_f32_16x16x128_fp8_fp8 v[8:11], v[12:15], v[0:7], v16 cbsz:1 abid:2 ; GISEL-NEXT: v_mov_b32_e32 v0, 0 ; GISEL-NEXT: s_nop 6 -; GISEL-NEXT: global_store_dwordx4 v0, v[14:17], s[0:1] +; GISEL-NEXT: global_store_dwordx4 v0, v[8:11], s[0:1] ; GISEL-NEXT: s_endpgm bb: %id = call i32 @llvm.amdgcn.workitem.id.x() diff --git a/llvm/test/CodeGen/AMDGPU/llvm.exp.ll b/llvm/test/CodeGen/AMDGPU/llvm.exp.ll index af79c91..ac356fa 100644 --- a/llvm/test/CodeGen/AMDGPU/llvm.exp.ll +++ b/llvm/test/CodeGen/AMDGPU/llvm.exp.ll @@ -6011,8 +6011,7 @@ define half @v_exp_f16_fast(half %in) { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, 0x3dc5 -; SI-GISEL-NEXT: v_mul_f32_e32 v0, v0, v1 +; SI-GISEL-NEXT: v_mul_f32_e32 v0, 0x3fb8a000, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 ; SI-GISEL-NEXT: v_exp_f32_e32 v0, v0 @@ -6512,10 +6511,9 @@ define <2 x half> @v_exp_v2f16_fast(<2 x half> %in) { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, 0x3dc5 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, v1 -; SI-GISEL-NEXT: v_mul_f32_e32 v0, v0, v2 -; SI-GISEL-NEXT: v_mul_f32_e32 v1, v1, v2 +; SI-GISEL-NEXT: v_mul_f32_e32 v0, 0x3fb8a000, v0 +; SI-GISEL-NEXT: v_mul_f32_e32 v1, 0x3fb8a000, v1 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 @@ -6709,12 +6707,11 @@ define <3 x half> @v_exp_v3f16_afn(<3 x half> %in) { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, 0x3dc5 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 -; SI-GISEL-NEXT: v_mul_f32_e32 v0, v0, v3 -; SI-GISEL-NEXT: v_mul_f32_e32 v1, v1, v3 -; SI-GISEL-NEXT: v_mul_f32_e32 v2, v2, v3 +; SI-GISEL-NEXT: v_mul_f32_e32 v0, 0x3fb8a000, v0 +; SI-GISEL-NEXT: v_mul_f32_e32 v1, 0x3fb8a000, v1 +; SI-GISEL-NEXT: v_mul_f32_e32 v2, 0x3fb8a000, v2 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v2, v2 diff --git a/llvm/test/CodeGen/AMDGPU/llvm.exp10.ll b/llvm/test/CodeGen/AMDGPU/llvm.exp10.ll index a99c199..d12ebe4 100644 --- a/llvm/test/CodeGen/AMDGPU/llvm.exp10.ll +++ b/llvm/test/CodeGen/AMDGPU/llvm.exp10.ll @@ -6092,8 +6092,7 @@ define half @v_exp10_f16_fast(half %in) { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, 0x3dc5 -; SI-GISEL-NEXT: v_mul_f32_e32 v0, v0, v1 +; SI-GISEL-NEXT: v_mul_f32_e32 v0, 0x3fb8a000, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 ; SI-GISEL-NEXT: v_exp_f32_e32 v0, v0 @@ -6594,10 +6593,9 @@ define <2 x half> @v_exp10_v2f16_fast(<2 x half> %in) { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, 0x3dc5 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, v1 -; SI-GISEL-NEXT: v_mul_f32_e32 v0, v0, v2 -; SI-GISEL-NEXT: v_mul_f32_e32 v1, v1, v2 +; SI-GISEL-NEXT: v_mul_f32_e32 v0, 0x3fb8a000, v0 +; SI-GISEL-NEXT: v_mul_f32_e32 v1, 0x3fb8a000, v1 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 @@ -6791,12 +6789,11 @@ define <3 x half> @v_exp10_v3f16_afn(<3 x half> %in) { ; SI-GISEL: ; %bb.0: ; SI-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v3, 0x3dc5 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f32_f16_e32 v2, v2 -; SI-GISEL-NEXT: v_mul_f32_e32 v0, v0, v3 -; SI-GISEL-NEXT: v_mul_f32_e32 v1, v1, v3 -; SI-GISEL-NEXT: v_mul_f32_e32 v2, v2, v3 +; SI-GISEL-NEXT: v_mul_f32_e32 v0, 0x3fb8a000, v0 +; SI-GISEL-NEXT: v_mul_f32_e32 v1, 0x3fb8a000, v1 +; SI-GISEL-NEXT: v_mul_f32_e32 v2, 0x3fb8a000, v2 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v1, v1 ; SI-GISEL-NEXT: v_cvt_f16_f32_e32 v2, v2 diff --git a/llvm/test/CodeGen/AMDGPU/mad-mix-hi.ll b/llvm/test/CodeGen/AMDGPU/mad-mix-hi.ll index 3f66c23..259ee0b 100644 --- a/llvm/test/CodeGen/AMDGPU/mad-mix-hi.ll +++ b/llvm/test/CodeGen/AMDGPU/mad-mix-hi.ll @@ -488,13 +488,11 @@ define <2 x half> @v_mad_mixhi_f16_f16lo_f16lo_f16lo_undeflo_clamp_postcvt(half ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v2 ; GISEL-CI-NEXT: v_mac_f32_e32 v2, v0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v2 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, 0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_max_f32_e32 v0, v0, v1 +; GISEL-CI-NEXT: v_max_f32_e32 v0, 0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_min_f32_e32 v0, v0, v1 +; GISEL-CI-NEXT: v_min_f32_e32 v0, 1.0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v0 ; GISEL-CI-NEXT: s_setpc_b64 s[30:31] %src0.ext = fpext half %src0 to float @@ -582,15 +580,13 @@ define <2 x half> @v_mad_mixhi_f16_f16lo_f16lo_f16lo_undeflo_clamp_postcvt_multi ; GISEL-CI-NEXT: s_mov_b32 s7, 0xf000 ; GISEL-CI-NEXT: v_mac_f32_e32 v2, v0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v2 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, 0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v0 +; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GISEL-CI-NEXT: buffer_store_short v0, off, s[4:7], 0 ; GISEL-CI-NEXT: s_waitcnt vmcnt(0) -; GISEL-CI-NEXT: v_max_f32_e32 v1, v2, v1 +; GISEL-CI-NEXT: v_max_f32_e32 v1, 0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GISEL-CI-NEXT: v_min_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_min_f32_e32 v1, 1.0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: s_setpc_b64 s[30:31] %src0.ext = fpext half %src0 to float diff --git a/llvm/test/CodeGen/AMDGPU/mad-mix-lo.ll b/llvm/test/CodeGen/AMDGPU/mad-mix-lo.ll index 21e6faf4..ba77552 100644 --- a/llvm/test/CodeGen/AMDGPU/mad-mix-lo.ll +++ b/llvm/test/CodeGen/AMDGPU/mad-mix-lo.ll @@ -313,13 +313,11 @@ define half @v_mad_mixlo_f16_f16lo_f16lo_f32_clamp_post_cvt(half %src0, half %sr ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 ; GISEL-CI-NEXT: v_mac_f32_e32 v2, v0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v2 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, 0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_max_f32_e32 v0, v0, v1 +; GISEL-CI-NEXT: v_max_f32_e32 v0, 0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_min_f32_e32 v0, v0, v1 +; GISEL-CI-NEXT: v_min_f32_e32 v0, 1.0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GISEL-CI-NEXT: s_setpc_b64 s[30:31] %src0.ext = fpext half %src0 to float @@ -1009,28 +1007,26 @@ define <2 x half> @v_mad_mix_v2f32_clamp_postcvt(<2 x half> %src0, <2 x half> %s ; GISEL-CI: ; %bb.0: ; GISEL-CI-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 +; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v2 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v4, v4 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v3, v3 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v5, v5 ; GISEL-CI-NEXT: v_mac_f32_e32 v4, v0, v2 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v4 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 0 ; GISEL-CI-NEXT: v_mac_f32_e32 v5, v1, v3 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v5 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GISEL-CI-NEXT: v_max_f32_e32 v0, v0, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v0, 0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GISEL-CI-NEXT: v_max_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v1, 0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GISEL-CI-NEXT: v_min_f32_e32 v0, v0, v2 +; GISEL-CI-NEXT: v_min_f32_e32 v0, 1.0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 -; GISEL-CI-NEXT: v_min_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_min_f32_e32 v1, 1.0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: s_setpc_b64 s[30:31] %src0.ext = fpext <2 x half> %src0 to <2 x float> @@ -1225,25 +1221,23 @@ define <3 x half> @v_mad_mix_v3f32_clamp_postcvt(<3 x half> %src0, <3 x half> %s ; GISEL-CI-NEXT: v_mac_f32_e32 v7, v1, v4 ; GISEL-CI-NEXT: v_mac_f32_e32 v8, v2, v5 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v7 -; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v3, v8 +; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v2, v8 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v3, v3 -; GISEL-CI-NEXT: v_max_f32_e32 v0, v0, v2 -; GISEL-CI-NEXT: v_max_f32_e32 v1, v1, v2 -; GISEL-CI-NEXT: v_max_f32_e32 v2, v3, v2 +; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v0, 0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 +; GISEL-CI-NEXT: v_max_f32_e32 v1, 0, v1 +; GISEL-CI-NEXT: v_max_f32_e32 v2, 0, v2 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v2, v2 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v3, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v2 -; GISEL-CI-NEXT: v_min_f32_e32 v0, v0, v3 -; GISEL-CI-NEXT: v_min_f32_e32 v1, v1, v3 -; GISEL-CI-NEXT: v_min_f32_e32 v2, v2, v3 +; GISEL-CI-NEXT: v_min_f32_e32 v0, 1.0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 +; GISEL-CI-NEXT: v_min_f32_e32 v1, 1.0, v1 +; GISEL-CI-NEXT: v_min_f32_e32 v2, 1.0, v2 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v2, v2 ; GISEL-CI-NEXT: s_setpc_b64 s[30:31] @@ -1441,30 +1435,28 @@ define <4 x half> @v_mad_mix_v4f32_clamp_postcvt(<4 x half> %src0, <4 x half> %s ; GISEL-CI-NEXT: v_mac_f32_e32 v11, v3, v7 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v8 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v9 -; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v3, v10 -; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v4, v11 +; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v2, v10 +; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v3, v11 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 +; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v2 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v3, v3 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v4, v4 -; GISEL-CI-NEXT: v_max_f32_e32 v0, v0, v2 -; GISEL-CI-NEXT: v_max_f32_e32 v1, v1, v2 -; GISEL-CI-NEXT: v_max_f32_e32 v3, v3, v2 -; GISEL-CI-NEXT: v_max_f32_e32 v2, v4, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v0, 0, v0 +; GISEL-CI-NEXT: v_max_f32_e32 v1, 0, v1 +; GISEL-CI-NEXT: v_max_f32_e32 v2, 0, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v3, 0, v3 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 -; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v2, v2 +; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v3, v3 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v5, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 +; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, v2 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v3, v3 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v4, v2 -; GISEL-CI-NEXT: v_min_f32_e32 v0, v0, v5 -; GISEL-CI-NEXT: v_min_f32_e32 v1, v1, v5 -; GISEL-CI-NEXT: v_min_f32_e32 v2, v3, v5 -; GISEL-CI-NEXT: v_min_f32_e32 v3, v4, v5 +; GISEL-CI-NEXT: v_min_f32_e32 v0, 1.0, v0 +; GISEL-CI-NEXT: v_min_f32_e32 v1, 1.0, v1 +; GISEL-CI-NEXT: v_min_f32_e32 v2, 1.0, v2 +; GISEL-CI-NEXT: v_min_f32_e32 v3, 1.0, v3 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v2, v2 @@ -1622,16 +1614,14 @@ define <2 x half> @v_mad_mix_v2f32_clamp_postcvt_lo(<2 x half> %src0, <2 x half> ; GISEL-CI-NEXT: v_mac_f32_e32 v4, v0, v2 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v5 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v4 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 0 ; GISEL-CI-NEXT: v_lshlrev_b32_e32 v0, 16, v0 ; GISEL-CI-NEXT: v_or_b32_e32 v0, v1, v0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v0 ; GISEL-CI-NEXT: v_and_b32_e32 v0, 0xffff0000, v0 -; GISEL-CI-NEXT: v_max_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v1, 0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GISEL-CI-NEXT: v_min_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_min_f32_e32 v1, 1.0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: v_or_b32_e32 v0, v0, v1 ; GISEL-CI-NEXT: v_lshrrev_b32_e32 v1, 16, v0 @@ -1790,17 +1780,15 @@ define <2 x half> @v_mad_mix_v2f32_clamp_postcvt_hi(<2 x half> %src0, <2 x half> ; GISEL-CI-NEXT: v_mac_f32_e32 v4, v0, v2 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v0, v5 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v4 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 0 ; GISEL-CI-NEXT: v_lshlrev_b32_e32 v0, 16, v0 ; GISEL-CI-NEXT: v_or_b32_e32 v0, v1, v0 ; GISEL-CI-NEXT: v_lshrrev_b32_e32 v1, 16, v0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 ; GISEL-CI-NEXT: v_and_b32_e32 v0, 0xffff, v0 -; GISEL-CI-NEXT: v_max_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_max_f32_e32 v1, 0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 -; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v2, 1.0 ; GISEL-CI-NEXT: v_cvt_f32_f16_e32 v1, v1 -; GISEL-CI-NEXT: v_min_f32_e32 v1, v1, v2 +; GISEL-CI-NEXT: v_min_f32_e32 v1, 1.0, v1 ; GISEL-CI-NEXT: v_cvt_f16_f32_e32 v1, v1 ; GISEL-CI-NEXT: v_lshlrev_b32_e32 v1, 16, v1 ; GISEL-CI-NEXT: v_or_b32_e32 v0, v0, v1 diff --git a/llvm/test/CodeGen/AMDGPU/maximumnum.ll b/llvm/test/CodeGen/AMDGPU/maximumnum.ll index 4f73e8e..c90b2c9 100644 --- a/llvm/test/CodeGen/AMDGPU/maximumnum.ll +++ b/llvm/test/CodeGen/AMDGPU/maximumnum.ll @@ -271,8 +271,7 @@ define half @v_maximumnum_f16_1.0(half %x) { ; GFX7-GISEL: ; %bb.0: ; GFX7-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX7-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX7-GISEL-NEXT: v_cvt_f32_f16_e32 v1, 1.0 -; GFX7-GISEL-NEXT: v_max_f32_e32 v0, v0, v1 +; GFX7-GISEL-NEXT: v_max_f32_e32 v0, 1.0, v0 ; GFX7-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX7-GISEL-NEXT: s_setpc_b64 s[30:31] ; diff --git a/llvm/test/CodeGen/AMDGPU/mfma-loop.ll b/llvm/test/CodeGen/AMDGPU/mfma-loop.ll index 0af655df..4bb6538 100644 --- a/llvm/test/CodeGen/AMDGPU/mfma-loop.ll +++ b/llvm/test/CodeGen/AMDGPU/mfma-loop.ll @@ -2399,8 +2399,9 @@ define amdgpu_kernel void @test_mfma_nested_loop_zeroinit(ptr addrspace(1) %arg) ; GFX90A-NEXT: v_accvgpr_mov_b32 a29, a0 ; GFX90A-NEXT: v_accvgpr_mov_b32 a30, a0 ; GFX90A-NEXT: v_accvgpr_mov_b32 a31, a0 -; GFX90A-NEXT: v_mov_b32_e32 v0, 2.0 -; GFX90A-NEXT: v_mov_b32_e32 v1, 1.0 +; GFX90A-NEXT: v_mov_b32_e32 v0, 1.0 +; GFX90A-NEXT: v_mov_b32_e32 v1, 2.0 +; GFX90A-NEXT: ; kill: def $agpr0_agpr1_agpr2_agpr3_agpr4_agpr5_agpr6_agpr7_agpr8_agpr9_agpr10_agpr11_agpr12_agpr13_agpr14_agpr15_agpr16_agpr17_agpr18_agpr19_agpr20_agpr21_agpr22_agpr23_agpr24_agpr25_agpr26_agpr27_agpr28_agpr29_agpr30_agpr31 killed $agpr0_agpr1_agpr2_agpr3_agpr4_agpr5_agpr6_agpr7_agpr8_agpr9_agpr10_agpr11_agpr12_agpr13_agpr14_agpr15_agpr16_agpr17_agpr18_agpr19_agpr20_agpr21_agpr22_agpr23_agpr24_agpr25_agpr26_agpr27_agpr28_agpr29_agpr30_agpr31 killed $exec ; GFX90A-NEXT: .LBB9_1: ; %for.cond.preheader ; GFX90A-NEXT: ; =>This Loop Header: Depth=1 ; GFX90A-NEXT: ; Child Loop BB9_2 Depth 2 @@ -2409,7 +2410,7 @@ define amdgpu_kernel void @test_mfma_nested_loop_zeroinit(ptr addrspace(1) %arg) ; GFX90A-NEXT: ; Parent Loop BB9_1 Depth=1 ; GFX90A-NEXT: ; => This Inner Loop Header: Depth=2 ; GFX90A-NEXT: s_nop 0 -; GFX90A-NEXT: v_mfma_f32_32x32x1f32 a[0:31], v1, v0, a[0:31] +; GFX90A-NEXT: v_mfma_f32_32x32x1f32 a[0:31], v0, v1, a[0:31] ; GFX90A-NEXT: s_add_i32 s1, s1, -1 ; GFX90A-NEXT: s_cmp_lg_u32 s1, 0 ; GFX90A-NEXT: s_cbranch_scc1 .LBB9_2 @@ -2468,8 +2469,9 @@ define amdgpu_kernel void @test_mfma_nested_loop_zeroinit(ptr addrspace(1) %arg) ; GFX942-NEXT: v_accvgpr_mov_b32 a29, a0 ; GFX942-NEXT: v_accvgpr_mov_b32 a30, a0 ; GFX942-NEXT: v_accvgpr_mov_b32 a31, a0 -; GFX942-NEXT: v_mov_b32_e32 v0, 2.0 -; GFX942-NEXT: v_mov_b32_e32 v1, 1.0 +; GFX942-NEXT: v_mov_b32_e32 v0, 1.0 +; GFX942-NEXT: v_mov_b32_e32 v1, 2.0 +; GFX942-NEXT: ; kill: def $agpr0_agpr1_agpr2_agpr3_agpr4_agpr5_agpr6_agpr7_agpr8_agpr9_agpr10_agpr11_agpr12_agpr13_agpr14_agpr15_agpr16_agpr17_agpr18_agpr19_agpr20_agpr21_agpr22_agpr23_agpr24_agpr25_agpr26_agpr27_agpr28_agpr29_agpr30_agpr31 killed $agpr0_agpr1_agpr2_agpr3_agpr4_agpr5_agpr6_agpr7_agpr8_agpr9_agpr10_agpr11_agpr12_agpr13_agpr14_agpr15_agpr16_agpr17_agpr18_agpr19_agpr20_agpr21_agpr22_agpr23_agpr24_agpr25_agpr26_agpr27_agpr28_agpr29_agpr30_agpr31 killed $exec ; GFX942-NEXT: .LBB9_1: ; %for.cond.preheader ; GFX942-NEXT: ; =>This Loop Header: Depth=1 ; GFX942-NEXT: ; Child Loop BB9_2 Depth 2 @@ -2478,7 +2480,7 @@ define amdgpu_kernel void @test_mfma_nested_loop_zeroinit(ptr addrspace(1) %arg) ; GFX942-NEXT: ; Parent Loop BB9_1 Depth=1 ; GFX942-NEXT: ; => This Inner Loop Header: Depth=2 ; GFX942-NEXT: s_nop 0 -; GFX942-NEXT: v_mfma_f32_32x32x1_2b_f32 a[0:31], v1, v0, a[0:31] +; GFX942-NEXT: v_mfma_f32_32x32x1_2b_f32 a[0:31], v0, v1, a[0:31] ; GFX942-NEXT: s_add_i32 s1, s1, -1 ; GFX942-NEXT: s_cmp_lg_u32 s1, 0 ; GFX942-NEXT: s_cbranch_scc1 .LBB9_2 diff --git a/llvm/test/CodeGen/AMDGPU/minimumnum.ll b/llvm/test/CodeGen/AMDGPU/minimumnum.ll index 558006d..64e8b7b 100644 --- a/llvm/test/CodeGen/AMDGPU/minimumnum.ll +++ b/llvm/test/CodeGen/AMDGPU/minimumnum.ll @@ -271,8 +271,7 @@ define half @v_minimumnum_f16_1.0(half %x) { ; GFX7-GISEL: ; %bb.0: ; GFX7-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX7-GISEL-NEXT: v_cvt_f32_f16_e32 v0, v0 -; GFX7-GISEL-NEXT: v_cvt_f32_f16_e32 v1, 1.0 -; GFX7-GISEL-NEXT: v_min_f32_e32 v0, v0, v1 +; GFX7-GISEL-NEXT: v_min_f32_e32 v0, 1.0, v0 ; GFX7-GISEL-NEXT: v_cvt_f16_f32_e32 v0, v0 ; GFX7-GISEL-NEXT: s_setpc_b64 s[30:31] ; diff --git a/llvm/test/CodeGen/AMDGPU/regpressure_printer.mir b/llvm/test/CodeGen/AMDGPU/regpressure_printer.mir index 8d5b5e4..b41aa08 100644 --- a/llvm/test/CodeGen/AMDGPU/regpressure_printer.mir +++ b/llvm/test/CodeGen/AMDGPU/regpressure_printer.mir @@ -510,14 +510,14 @@ body: | ; RPU-NEXT: 0 0 $sgpr0 = S_BUFFER_LOAD_DWORD_IMM $sgpr0_sgpr1_sgpr2_sgpr3, 0, 0 ; RPU-NEXT: 0 0 ; RPU-NEXT: 0 1 undef %0.sub5:vreg_512 = V_MOV_B32_e32 5, implicit $exec - ; RPU-NEXT: 0 0 - ; RPU-NEXT: 0 0 S_CMP_GT_U32 $sgpr0, 15, implicit-def $scc - ; RPU-NEXT: 0 0 - ; RPU-NEXT: 0 0 S_CBRANCH_SCC1 %bb.2, implicit $scc - ; RPU-NEXT: 0 0 - ; RPU-NEXT: 0 0 S_BRANCH %bb.1 - ; RPU-NEXT: 0 0 - ; RPU-NEXT: Live-out: + ; RPU-NEXT: 0 1 + ; RPU-NEXT: 0 1 S_CMP_GT_U32 $sgpr0, 15, implicit-def $scc + ; RPU-NEXT: 0 1 + ; RPU-NEXT: 0 1 S_CBRANCH_SCC1 %bb.2, implicit $scc + ; RPU-NEXT: 0 1 + ; RPU-NEXT: 0 1 S_BRANCH %bb.1 + ; RPU-NEXT: 0 1 + ; RPU-NEXT: Live-out: %0:0000000000000C00 ; RPU-NEXT: Live-thr: ; RPU-NEXT: 0 0 ; RPU-NEXT: bb.1: @@ -571,8 +571,6 @@ body: | ; RPD-NEXT: 0 1 S_BRANCH %bb.1 ; RPD-NEXT: 0 1 ; RPD-NEXT: Live-out: %0:0000000000000C00 - ; RPD-NEXT: mis LIS: - ; RPD-NEXT: %0:L0000000000000C00 isn't found in LIS reported set ; RPD-NEXT: Live-thr: ; RPD-NEXT: 0 0 ; RPD-NEXT: bb.1: diff --git a/llvm/test/CodeGen/AMDGPU/uniform-select.ll b/llvm/test/CodeGen/AMDGPU/uniform-select.ll index f001bf0..b52913f 100644 --- a/llvm/test/CodeGen/AMDGPU/uniform-select.ll +++ b/llvm/test/CodeGen/AMDGPU/uniform-select.ll @@ -20,34 +20,34 @@ define amdgpu_kernel void @test_insert_extract(i32 %p, i32 %q) { ; GFX90A-NEXT: s_cmp_eq_u32 s1, 1 ; GFX90A-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX90A-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX90A-NEXT: s_cselect_b32 s7, s4, s3 +; GFX90A-NEXT: s_cselect_b32 s7, s3, s2 ; GFX90A-NEXT: s_cmp_eq_u32 s1, 2 ; GFX90A-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX90A-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX90A-NEXT: s_cselect_b32 s7, s5, s7 +; GFX90A-NEXT: s_cselect_b32 s7, s4, s7 ; GFX90A-NEXT: s_cmp_eq_u32 s1, 3 ; GFX90A-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX90A-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX90A-NEXT: s_cselect_b32 s7, s6, s7 +; GFX90A-NEXT: s_cselect_b32 s7, s5, s7 ; GFX90A-NEXT: s_or_b32 s7, s7, s0 ; GFX90A-NEXT: s_cmp_eq_u32 s1, 1 ; GFX90A-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX90A-NEXT: s_and_b64 s[10:11], s[8:9], exec -; GFX90A-NEXT: s_cselect_b32 s4, s7, s4 +; GFX90A-NEXT: s_cselect_b32 s3, s7, s3 ; GFX90A-NEXT: s_cmp_eq_u32 s1, 3 ; GFX90A-NEXT: s_cselect_b64 s[10:11], -1, 0 ; GFX90A-NEXT: s_and_b64 s[12:13], s[10:11], exec -; GFX90A-NEXT: s_cselect_b32 s6, s7, s6 +; GFX90A-NEXT: s_cselect_b32 s5, s7, s5 ; GFX90A-NEXT: s_cmp_eq_u32 s1, 2 ; GFX90A-NEXT: s_cselect_b64 s[12:13], -1, 0 ; GFX90A-NEXT: s_and_b64 s[14:15], s[12:13], exec -; GFX90A-NEXT: s_cselect_b32 s5, s7, s5 +; GFX90A-NEXT: s_cselect_b32 s4, s7, s4 ; GFX90A-NEXT: s_cmp_eq_u32 s1, 0 -; GFX90A-NEXT: s_cselect_b32 s3, s7, s3 +; GFX90A-NEXT: s_cselect_b32 s2, s7, s2 ; GFX90A-NEXT: s_or_b64 s[8:9], s[12:13], s[8:9] ; GFX90A-NEXT: s_or_b64 s[8:9], s[10:11], s[8:9] ; GFX90A-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX90A-NEXT: s_cselect_b32 s2, 0, s2 +; GFX90A-NEXT: s_cselect_b32 s6, 0, s6 ; GFX90A-NEXT: s_mov_b64 vcc, vcc ; GFX90A-NEXT: s_cbranch_vccnz .LBB0_1 ; GFX90A-NEXT: ; %bb.2: ; %DummyReturnBlock @@ -68,34 +68,34 @@ define amdgpu_kernel void @test_insert_extract(i32 %p, i32 %q) { ; GFX942-NEXT: s_cmp_eq_u32 s1, 1 ; GFX942-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX942-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX942-NEXT: s_cselect_b32 s7, s4, s3 +; GFX942-NEXT: s_cselect_b32 s7, s3, s2 ; GFX942-NEXT: s_cmp_eq_u32 s1, 2 ; GFX942-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX942-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX942-NEXT: s_cselect_b32 s7, s5, s7 +; GFX942-NEXT: s_cselect_b32 s7, s4, s7 ; GFX942-NEXT: s_cmp_eq_u32 s1, 3 ; GFX942-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX942-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX942-NEXT: s_cselect_b32 s7, s6, s7 +; GFX942-NEXT: s_cselect_b32 s7, s5, s7 ; GFX942-NEXT: s_or_b32 s7, s7, s0 ; GFX942-NEXT: s_cmp_eq_u32 s1, 1 ; GFX942-NEXT: s_cselect_b64 s[8:9], -1, 0 ; GFX942-NEXT: s_and_b64 s[10:11], s[8:9], exec -; GFX942-NEXT: s_cselect_b32 s4, s7, s4 +; GFX942-NEXT: s_cselect_b32 s3, s7, s3 ; GFX942-NEXT: s_cmp_eq_u32 s1, 3 ; GFX942-NEXT: s_cselect_b64 s[10:11], -1, 0 ; GFX942-NEXT: s_and_b64 s[12:13], s[10:11], exec -; GFX942-NEXT: s_cselect_b32 s6, s7, s6 +; GFX942-NEXT: s_cselect_b32 s5, s7, s5 ; GFX942-NEXT: s_cmp_eq_u32 s1, 2 ; GFX942-NEXT: s_cselect_b64 s[12:13], -1, 0 ; GFX942-NEXT: s_and_b64 s[14:15], s[12:13], exec -; GFX942-NEXT: s_cselect_b32 s5, s7, s5 +; GFX942-NEXT: s_cselect_b32 s4, s7, s4 ; GFX942-NEXT: s_cmp_eq_u32 s1, 0 -; GFX942-NEXT: s_cselect_b32 s3, s7, s3 +; GFX942-NEXT: s_cselect_b32 s2, s7, s2 ; GFX942-NEXT: s_or_b64 s[8:9], s[12:13], s[8:9] ; GFX942-NEXT: s_or_b64 s[8:9], s[10:11], s[8:9] ; GFX942-NEXT: s_and_b64 s[8:9], s[8:9], exec -; GFX942-NEXT: s_cselect_b32 s2, 0, s2 +; GFX942-NEXT: s_cselect_b32 s6, 0, s6 ; GFX942-NEXT: s_mov_b64 vcc, vcc ; GFX942-NEXT: s_cbranch_vccnz .LBB0_1 ; GFX942-NEXT: ; %bb.2: ; %DummyReturnBlock @@ -117,34 +117,34 @@ define amdgpu_kernel void @test_insert_extract(i32 %p, i32 %q) { ; GFX1030-NEXT: s_cmp_eq_u32 s1, 1 ; GFX1030-NEXT: s_cselect_b32 s7, -1, 0 ; GFX1030-NEXT: s_and_b32 s7, s7, exec_lo -; GFX1030-NEXT: s_cselect_b32 s7, s4, s3 +; GFX1030-NEXT: s_cselect_b32 s7, s3, s2 ; GFX1030-NEXT: s_cmp_eq_u32 s1, 2 ; GFX1030-NEXT: s_cselect_b32 s8, -1, 0 ; GFX1030-NEXT: s_and_b32 s8, s8, exec_lo -; GFX1030-NEXT: s_cselect_b32 s7, s5, s7 +; GFX1030-NEXT: s_cselect_b32 s7, s4, s7 ; GFX1030-NEXT: s_cmp_eq_u32 s1, 3 ; GFX1030-NEXT: s_cselect_b32 s8, -1, 0 ; GFX1030-NEXT: s_and_b32 s8, s8, exec_lo -; GFX1030-NEXT: s_cselect_b32 s7, s6, s7 +; GFX1030-NEXT: s_cselect_b32 s7, s5, s7 ; GFX1030-NEXT: s_or_b32 s7, s7, s0 ; GFX1030-NEXT: s_cmp_eq_u32 s1, 1 ; GFX1030-NEXT: s_cselect_b32 s8, -1, 0 ; GFX1030-NEXT: s_and_b32 s9, s8, exec_lo -; GFX1030-NEXT: s_cselect_b32 s4, s7, s4 +; GFX1030-NEXT: s_cselect_b32 s3, s7, s3 ; GFX1030-NEXT: s_cmp_eq_u32 s1, 3 ; GFX1030-NEXT: s_cselect_b32 s9, -1, 0 ; GFX1030-NEXT: s_and_b32 s10, s9, exec_lo -; GFX1030-NEXT: s_cselect_b32 s6, s7, s6 +; GFX1030-NEXT: s_cselect_b32 s5, s7, s5 ; GFX1030-NEXT: s_cmp_eq_u32 s1, 2 ; GFX1030-NEXT: s_cselect_b32 s10, -1, 0 ; GFX1030-NEXT: s_and_b32 s11, s10, exec_lo -; GFX1030-NEXT: s_cselect_b32 s5, s7, s5 +; GFX1030-NEXT: s_cselect_b32 s4, s7, s4 ; GFX1030-NEXT: s_cmp_eq_u32 s1, 0 -; GFX1030-NEXT: s_cselect_b32 s3, s7, s3 +; GFX1030-NEXT: s_cselect_b32 s2, s7, s2 ; GFX1030-NEXT: s_or_b32 s7, s10, s8 ; GFX1030-NEXT: s_or_b32 s7, s9, s7 ; GFX1030-NEXT: s_and_b32 s7, s7, exec_lo -; GFX1030-NEXT: s_cselect_b32 s2, 0, s2 +; GFX1030-NEXT: s_cselect_b32 s6, 0, s6 ; GFX1030-NEXT: s_cbranch_vccnz .LBB0_1 ; GFX1030-NEXT: ; %bb.2: ; %DummyReturnBlock ; GFX1030-NEXT: s_endpgm @@ -166,38 +166,38 @@ define amdgpu_kernel void @test_insert_extract(i32 %p, i32 %q) { ; GFX1100-NEXT: s_cselect_b32 s7, -1, 0 ; GFX1100-NEXT: s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_3) | instid1(SALU_CYCLE_1) ; GFX1100-NEXT: s_and_b32 s7, s7, exec_lo -; GFX1100-NEXT: s_cselect_b32 s7, s4, s3 +; GFX1100-NEXT: s_cselect_b32 s7, s3, s2 ; GFX1100-NEXT: s_cmp_eq_u32 s1, 2 ; GFX1100-NEXT: s_cselect_b32 s8, -1, 0 ; GFX1100-NEXT: s_and_b32 s8, s8, exec_lo -; GFX1100-NEXT: s_cselect_b32 s7, s5, s7 +; GFX1100-NEXT: s_cselect_b32 s7, s4, s7 ; GFX1100-NEXT: s_cmp_eq_u32 s1, 3 ; GFX1100-NEXT: s_cselect_b32 s8, -1, 0 ; GFX1100-NEXT: s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_1) | instid1(SALU_CYCLE_1) ; GFX1100-NEXT: s_and_b32 s8, s8, exec_lo -; GFX1100-NEXT: s_cselect_b32 s7, s6, s7 +; GFX1100-NEXT: s_cselect_b32 s7, s5, s7 ; GFX1100-NEXT: s_or_b32 s7, s7, s0 ; GFX1100-NEXT: s_cmp_eq_u32 s1, 1 ; GFX1100-NEXT: s_cselect_b32 s8, -1, 0 ; GFX1100-NEXT: s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_3) | instid1(SALU_CYCLE_1) ; GFX1100-NEXT: s_and_b32 s9, s8, exec_lo -; GFX1100-NEXT: s_cselect_b32 s4, s7, s4 +; GFX1100-NEXT: s_cselect_b32 s3, s7, s3 ; GFX1100-NEXT: s_cmp_eq_u32 s1, 3 ; GFX1100-NEXT: s_cselect_b32 s9, -1, 0 ; GFX1100-NEXT: s_and_b32 s10, s9, exec_lo -; GFX1100-NEXT: s_cselect_b32 s6, s7, s6 +; GFX1100-NEXT: s_cselect_b32 s5, s7, s5 ; GFX1100-NEXT: s_cmp_eq_u32 s1, 2 ; GFX1100-NEXT: s_cselect_b32 s10, -1, 0 ; GFX1100-NEXT: s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_4) | instid1(SALU_CYCLE_1) ; GFX1100-NEXT: s_and_b32 s11, s10, exec_lo -; GFX1100-NEXT: s_cselect_b32 s5, s7, s5 +; GFX1100-NEXT: s_cselect_b32 s4, s7, s4 ; GFX1100-NEXT: s_cmp_eq_u32 s1, 0 -; GFX1100-NEXT: s_cselect_b32 s3, s7, s3 +; GFX1100-NEXT: s_cselect_b32 s2, s7, s2 ; GFX1100-NEXT: s_or_b32 s7, s10, s8 ; GFX1100-NEXT: s_or_b32 s7, s9, s7 ; GFX1100-NEXT: s_delay_alu instid0(SALU_CYCLE_1) ; GFX1100-NEXT: s_and_b32 s7, s7, exec_lo -; GFX1100-NEXT: s_cselect_b32 s2, 0, s2 +; GFX1100-NEXT: s_cselect_b32 s6, 0, s6 ; GFX1100-NEXT: s_cbranch_vccnz .LBB0_1 ; GFX1100-NEXT: ; %bb.2: ; %DummyReturnBlock ; GFX1100-NEXT: s_endpgm diff --git a/llvm/test/CodeGen/AMDGPU/v_sat_pk_u8_i16.ll b/llvm/test/CodeGen/AMDGPU/v_sat_pk_u8_i16.ll index 6b5bae0..c9b94e0 100644 --- a/llvm/test/CodeGen/AMDGPU/v_sat_pk_u8_i16.ll +++ b/llvm/test/CodeGen/AMDGPU/v_sat_pk_u8_i16.ll @@ -6,12 +6,12 @@ ; RUN: llc -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=SDAG-GFX12,SDAG-GFX12-TRUE16 %s ; RUN: llc -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=SDAG-GFX12,SDAG-GFX12-FAKE16 %s -; RUN: llc -mtriple=amdgcn -mcpu=fiji -global-isel < %s | FileCheck -check-prefixes=GISEL-VI %s -; RUN: llc -mtriple=amdgcn -mcpu=gfx900 -global-isel < %s | FileCheck -check-prefixes=GISEL-GFX9 %s -; RUN: llc -mtriple=amdgcn -mcpu=gfx1101 -mattr=+real-true16 -global-isel < %s | FileCheck -check-prefixes=GFX11,GISEL-GFX11,GISEL-GFX11-TRUE16 %s -; RUN: llc -mtriple=amdgcn -mcpu=gfx1101 -mattr=-real-true16 -global-isel < %s | FileCheck -check-prefixes=GFX11,GISEL-GFX11,GISEL-GFX11-FAKE16 %s -; RUN: llc -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 -global-isel < %s | FileCheck -check-prefixes=GISEL-GFX12,GISEL-GFX12-TRUE16 %s -; RUN: llc -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 -global-isel < %s | FileCheck -check-prefixes=GISEL-GFX12,GISEL-GFX12-FAKE16 %s +; RUN: llc -mtriple=amdgcn -mcpu=fiji -global-isel -new-reg-bank-select < %s | FileCheck -check-prefixes=GISEL-VI %s +; RUN: llc -mtriple=amdgcn -mcpu=gfx900 -global-isel -new-reg-bank-select < %s | FileCheck -check-prefixes=GISEL-GFX9 %s +; RUN: llc -mtriple=amdgcn -mcpu=gfx1101 -mattr=+real-true16 -global-isel -new-reg-bank-select < %s | FileCheck -check-prefixes=GFX11,GISEL-GFX11,GISEL-GFX11-TRUE16 %s +; RUN: llc -mtriple=amdgcn -mcpu=gfx1101 -mattr=-real-true16 -global-isel -new-reg-bank-select < %s | FileCheck -check-prefixes=GFX11,GISEL-GFX11,GISEL-GFX11-FAKE16 %s +; RUN: llc -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 -global-isel -new-reg-bank-select < %s | FileCheck -check-prefixes=GISEL-GFX12,GISEL-GFX12-TRUE16 %s +; RUN: llc -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 -global-isel -new-reg-bank-select < %s | FileCheck -check-prefixes=GISEL-GFX12,GISEL-GFX12-FAKE16 %s ; <GFX9 has no V_SAT_PK, GFX9+ has V_SAT_PK, GFX11 has V_SAT_PK with t16 diff --git a/llvm/test/CodeGen/AMDGPU/vector-reduce-smax.ll b/llvm/test/CodeGen/AMDGPU/vector-reduce-smax.ll index b5d9d00..8d0e003 100644 --- a/llvm/test/CodeGen/AMDGPU/vector-reduce-smax.ll +++ b/llvm/test/CodeGen/AMDGPU/vector-reduce-smax.ll @@ -1,21 +1,21 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5 ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-FAKE16 %s ; FIXME-TRUE16. enable gisel -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-FAKE16 %s -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s define i8 @test_vector_reduce_smax_v2i8(<2 x i8> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smax_v2i8: @@ -1632,6 +1632,7 @@ entry: ret i8 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smax_v2i16(<2 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smax_v2i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1678,7 +1679,7 @@ define i16 @test_vector_reduce_smax_v2i16(<2 x i16> %v) { ; GFX9-GISEL-LABEL: test_vector_reduce_smax_v2i16: ; GFX9-GISEL: ; %bb.0: ; %entry ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1692,7 +1693,7 @@ define i16 @test_vector_reduce_smax_v2i16(<2 x i16> %v) { ; GFX10-GISEL-LABEL: test_vector_reduce_smax_v2i16: ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1713,7 +1714,7 @@ define i16 @test_vector_reduce_smax_v2i16(<2 x i16> %v) { ; GFX11-GISEL-LABEL: test_vector_reduce_smax_v2i16: ; GFX11-GISEL: ; %bb.0: ; %entry ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1747,7 +1748,7 @@ define i16 @test_vector_reduce_smax_v2i16(<2 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_samplecnt 0x0 ; GFX12-GISEL-NEXT: s_wait_bvhcnt 0x0 ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1900,6 +1901,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smax_v4i16(<4 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smax_v4i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1961,7 +1963,7 @@ define i16 @test_vector_reduce_smax_v4i16(<4 x i16> %v) { ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1977,7 +1979,7 @@ define i16 @test_vector_reduce_smax_v4i16(<4 x i16> %v) { ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2003,7 +2005,7 @@ define i16 @test_vector_reduce_smax_v4i16(<4 x i16> %v) { ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2041,7 +2043,7 @@ define i16 @test_vector_reduce_smax_v4i16(<4 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] entry: @@ -2049,6 +2051,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smax_v8i16(<8 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smax_v8i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -2139,7 +2142,7 @@ define i16 @test_vector_reduce_smax_v8i16(<8 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2159,7 +2162,7 @@ define i16 @test_vector_reduce_smax_v8i16(<8 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_max_i16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2192,7 +2195,7 @@ define i16 @test_vector_reduce_smax_v8i16(<8 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_max_i16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2238,7 +2241,7 @@ define i16 @test_vector_reduce_smax_v8i16(<8 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_max_i16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2247,6 +2250,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smax_v16i16(<16 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smax_v16i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -2391,7 +2395,7 @@ define i16 @test_vector_reduce_smax_v16i16(<16 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2419,7 +2423,7 @@ define i16 @test_vector_reduce_smax_v16i16(<16 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_max_i16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2467,7 +2471,7 @@ define i16 @test_vector_reduce_smax_v16i16(<16 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_max_i16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2528,7 +2532,7 @@ define i16 @test_vector_reduce_smax_v16i16(<16 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_max_i16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] diff --git a/llvm/test/CodeGen/AMDGPU/vector-reduce-smin.ll b/llvm/test/CodeGen/AMDGPU/vector-reduce-smin.ll index 2a989ec..f15ecf0 100644 --- a/llvm/test/CodeGen/AMDGPU/vector-reduce-smin.ll +++ b/llvm/test/CodeGen/AMDGPU/vector-reduce-smin.ll @@ -1,21 +1,21 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5 ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-FAKE16 %s ; FIXME-TRUE16. enable gisel -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-FAKE16 %s -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s define i8 @test_vector_reduce_smin_v2i8(<2 x i8> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smin_v2i8: @@ -1632,6 +1632,7 @@ entry: ret i8 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smin_v2i16(<2 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smin_v2i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1678,7 +1679,7 @@ define i16 @test_vector_reduce_smin_v2i16(<2 x i16> %v) { ; GFX9-GISEL-LABEL: test_vector_reduce_smin_v2i16: ; GFX9-GISEL: ; %bb.0: ; %entry ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1692,7 +1693,7 @@ define i16 @test_vector_reduce_smin_v2i16(<2 x i16> %v) { ; GFX10-GISEL-LABEL: test_vector_reduce_smin_v2i16: ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1713,7 +1714,7 @@ define i16 @test_vector_reduce_smin_v2i16(<2 x i16> %v) { ; GFX11-GISEL-LABEL: test_vector_reduce_smin_v2i16: ; GFX11-GISEL: ; %bb.0: ; %entry ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1747,7 +1748,7 @@ define i16 @test_vector_reduce_smin_v2i16(<2 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_samplecnt 0x0 ; GFX12-GISEL-NEXT: s_wait_bvhcnt 0x0 ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1900,6 +1901,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smin_v4i16(<4 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smin_v4i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1961,7 +1963,7 @@ define i16 @test_vector_reduce_smin_v4i16(<4 x i16> %v) { ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1977,7 +1979,7 @@ define i16 @test_vector_reduce_smin_v4i16(<4 x i16> %v) { ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2003,7 +2005,7 @@ define i16 @test_vector_reduce_smin_v4i16(<4 x i16> %v) { ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2041,7 +2043,7 @@ define i16 @test_vector_reduce_smin_v4i16(<4 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] entry: @@ -2049,6 +2051,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_smin_v8i16(<8 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_smin_v8i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -2139,7 +2142,7 @@ define i16 @test_vector_reduce_smin_v8i16(<8 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2159,7 +2162,7 @@ define i16 @test_vector_reduce_smin_v8i16(<8 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_min_i16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2192,7 +2195,7 @@ define i16 @test_vector_reduce_smin_v8i16(<8 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_min_i16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2238,7 +2241,7 @@ define i16 @test_vector_reduce_smin_v8i16(<8 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_min_i16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2391,7 +2394,7 @@ define i16 @test_vector_reduce_smin_v16i16(<16 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2419,7 +2422,7 @@ define i16 @test_vector_reduce_smin_v16i16(<16 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_min_i16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2467,7 +2470,7 @@ define i16 @test_vector_reduce_smin_v16i16(<16 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_min_i16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2528,7 +2531,7 @@ define i16 @test_vector_reduce_smin_v16i16(<16 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_min_i16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_i16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] diff --git a/llvm/test/CodeGen/AMDGPU/vector-reduce-umax.ll b/llvm/test/CodeGen/AMDGPU/vector-reduce-umax.ll index 69fd58a..e62165c 100644 --- a/llvm/test/CodeGen/AMDGPU/vector-reduce-umax.ll +++ b/llvm/test/CodeGen/AMDGPU/vector-reduce-umax.ll @@ -1,21 +1,21 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5 ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-FAKE16 %s ; FIXME-TRUE16. enable gisel -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-FAKE16 %s -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s define i8 @test_vector_reduce_umax_v2i8(<2 x i8> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umax_v2i8: @@ -1525,6 +1525,7 @@ entry: ret i8 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umax_v2i16(<2 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umax_v2i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1569,7 +1570,7 @@ define i16 @test_vector_reduce_umax_v2i16(<2 x i16> %v) { ; GFX9-GISEL-LABEL: test_vector_reduce_umax_v2i16: ; GFX9-GISEL: ; %bb.0: ; %entry ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1583,7 +1584,7 @@ define i16 @test_vector_reduce_umax_v2i16(<2 x i16> %v) { ; GFX10-GISEL-LABEL: test_vector_reduce_umax_v2i16: ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1604,7 +1605,7 @@ define i16 @test_vector_reduce_umax_v2i16(<2 x i16> %v) { ; GFX11-GISEL-LABEL: test_vector_reduce_umax_v2i16: ; GFX11-GISEL: ; %bb.0: ; %entry ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1638,7 +1639,7 @@ define i16 @test_vector_reduce_umax_v2i16(<2 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_samplecnt 0x0 ; GFX12-GISEL-NEXT: s_wait_bvhcnt 0x0 ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1782,6 +1783,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umax_v4i16(<4 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umax_v4i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1841,7 +1843,7 @@ define i16 @test_vector_reduce_umax_v4i16(<4 x i16> %v) { ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1857,7 +1859,7 @@ define i16 @test_vector_reduce_umax_v4i16(<4 x i16> %v) { ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1883,7 +1885,7 @@ define i16 @test_vector_reduce_umax_v4i16(<4 x i16> %v) { ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1921,7 +1923,7 @@ define i16 @test_vector_reduce_umax_v4i16(<4 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] entry: @@ -1929,6 +1931,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umax_v8i16(<8 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umax_v8i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -2017,7 +2020,7 @@ define i16 @test_vector_reduce_umax_v8i16(<8 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2037,7 +2040,7 @@ define i16 @test_vector_reduce_umax_v8i16(<8 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_max_u16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2070,7 +2073,7 @@ define i16 @test_vector_reduce_umax_v8i16(<8 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_max_u16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2116,7 +2119,7 @@ define i16 @test_vector_reduce_umax_v8i16(<8 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_max_u16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2125,6 +2128,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umax_v16i16(<16 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umax_v16i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -2267,7 +2271,7 @@ define i16 @test_vector_reduce_umax_v16i16(<16 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2295,7 +2299,7 @@ define i16 @test_vector_reduce_umax_v16i16(<16 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_max_u16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2343,7 +2347,7 @@ define i16 @test_vector_reduce_umax_v16i16(<16 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_max_u16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2404,7 +2408,7 @@ define i16 @test_vector_reduce_umax_v16i16(<16 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_max_u16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_max_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] diff --git a/llvm/test/CodeGen/AMDGPU/vector-reduce-umin.ll b/llvm/test/CodeGen/AMDGPU/vector-reduce-umin.ll index 1d3b42e..83ecaaa 100644 --- a/llvm/test/CodeGen/AMDGPU/vector-reduce-umin.ll +++ b/llvm/test/CodeGen/AMDGPU/vector-reduce-umin.ll @@ -1,21 +1,21 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5 ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx700 < %s | FileCheck -check-prefixes=GFX7,GFX7-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx801 < %s | FileCheck -check-prefixes=GFX8,GFX8-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx942 < %s | FileCheck -check-prefixes=GFX9,GFX9-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-SDAG %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1010 < %s | FileCheck -check-prefixes=GFX10,GFX10-GISEL %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-SDAG,GFX11-SDAG-FAKE16 %s ; FIXME-TRUE16. enable gisel -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1100 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX11,GFX11-GISEL,GFX11-GISEL-FAKE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-TRUE16 %s ; RUN: llc -global-isel=0 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-SDAG,GFX12-SDAG-FAKE16 %s -; XUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s -; RUN: llc -global-isel=1 -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s +; XUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=+real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-TRUE16 %s +; RUN: llc -global-isel=1 -new-reg-bank-select -mtriple=amdgcn -mcpu=gfx1200 -mattr=-real-true16 < %s | FileCheck -check-prefixes=GFX12,GFX12-GISEL,GFX12-GISEL-FAKE16 %s define i8 @test_vector_reduce_umin_v2i8(<2 x i8> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umin_v2i8: @@ -1271,6 +1271,7 @@ entry: ret i8 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umin_v2i16(<2 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umin_v2i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1312,7 +1313,7 @@ define i16 @test_vector_reduce_umin_v2i16(<2 x i16> %v) { ; GFX9-GISEL-LABEL: test_vector_reduce_umin_v2i16: ; GFX9-GISEL: ; %bb.0: ; %entry ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1326,7 +1327,7 @@ define i16 @test_vector_reduce_umin_v2i16(<2 x i16> %v) { ; GFX10-GISEL-LABEL: test_vector_reduce_umin_v2i16: ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1347,7 +1348,7 @@ define i16 @test_vector_reduce_umin_v2i16(<2 x i16> %v) { ; GFX11-GISEL-LABEL: test_vector_reduce_umin_v2i16: ; GFX11-GISEL: ; %bb.0: ; %entry ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1381,7 +1382,7 @@ define i16 @test_vector_reduce_umin_v2i16(<2 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_samplecnt 0x0 ; GFX12-GISEL-NEXT: s_wait_bvhcnt 0x0 ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1527,6 +1528,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umin_v4i16(<4 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umin_v4i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1583,7 +1585,7 @@ define i16 @test_vector_reduce_umin_v4i16(<4 x i16> %v) { ; GFX9-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1599,7 +1601,7 @@ define i16 @test_vector_reduce_umin_v4i16(<4 x i16> %v) { ; GFX10-GISEL: ; %bb.0: ; %entry ; GFX10-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1625,7 +1627,7 @@ define i16 @test_vector_reduce_umin_v4i16(<4 x i16> %v) { ; GFX11-GISEL-NEXT: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1663,7 +1665,7 @@ define i16 @test_vector_reduce_umin_v4i16(<4 x i16> %v) { ; GFX12-GISEL-NEXT: s_wait_kmcnt 0x0 ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] entry: @@ -1671,6 +1673,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umin_v8i16(<8 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umin_v8i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -1756,7 +1759,7 @@ define i16 @test_vector_reduce_umin_v8i16(<8 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1776,7 +1779,7 @@ define i16 @test_vector_reduce_umin_v8i16(<8 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_min_u16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -1809,7 +1812,7 @@ define i16 @test_vector_reduce_umin_v8i16(<8 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_min_u16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1855,7 +1858,7 @@ define i16 @test_vector_reduce_umin_v8i16(<8 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_min_u16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -1864,6 +1867,7 @@ entry: ret i16 %res } +; FIXME: With -new-reg-bank-select, v_alignbit_b32 is regression. Need pattern to look through COPY. define i16 @test_vector_reduce_umin_v16i16(<16 x i16> %v) { ; GFX7-SDAG-LABEL: test_vector_reduce_umin_v16i16: ; GFX7-SDAG: ; %bb.0: ; %entry @@ -2003,7 +2007,7 @@ define i16 @test_vector_reduce_umin_v16i16(<16 x i16> %v) { ; GFX9-GISEL-NEXT: s_nop 0 ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_nop 0 -; GFX9-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX9-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX9-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX9-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2031,7 +2035,7 @@ define i16 @test_vector_reduce_umin_v16i16(<16 x i16> %v) { ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v2 ; GFX10-GISEL-NEXT: v_pk_min_u16 v1, v1, v3 ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX10-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX10-GISEL-NEXT: v_alignbit_b32 v1, s4, v0, 16 ; GFX10-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX10-GISEL-NEXT: s_setpc_b64 s[30:31] ; @@ -2079,7 +2083,7 @@ define i16 @test_vector_reduce_umin_v16i16(<16 x i16> %v) { ; GFX11-GISEL-NEXT: v_pk_min_u16 v1, v1, v3 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX11-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX11-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX11-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX11-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX11-GISEL-NEXT: s_setpc_b64 s[30:31] @@ -2140,7 +2144,7 @@ define i16 @test_vector_reduce_umin_v16i16(<16 x i16> %v) { ; GFX12-GISEL-NEXT: v_pk_min_u16 v1, v1, v3 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 -; GFX12-GISEL-NEXT: v_lshrrev_b32_e32 v1, 16, v0 +; GFX12-GISEL-NEXT: v_alignbit_b32 v1, s0, v0, 16 ; GFX12-GISEL-NEXT: s_delay_alu instid0(VALU_DEP_1) ; GFX12-GISEL-NEXT: v_pk_min_u16 v0, v0, v1 ; GFX12-GISEL-NEXT: s_setpc_b64 s[30:31] diff --git a/llvm/test/CodeGen/ARM/sincos.ll b/llvm/test/CodeGen/ARM/sincos.ll index e1b683a..1a4313e 100644 --- a/llvm/test/CodeGen/ARM/sincos.ll +++ b/llvm/test/CodeGen/ARM/sincos.ll @@ -2,8 +2,7 @@ ; RUN: llc < %s -mtriple=armv7-apple-ios7 -mcpu=cortex-a8 | FileCheck %s --check-prefix=SINCOS ; RUN: llc < %s -mtriple=armv7-linux-gnu -mcpu=cortex-a8 | FileCheck %s --check-prefix=SINCOS-GNU ; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a8 | FileCheck %s --check-prefix=SINCOS-GNU -; RUN: llc < %s -mtriple=armv7-linux-android -mcpu=cortex-a8 | FileCheck %s --check-prefix=NOOPT-ANDROID -; RUN: llc < %s -mtriple=armv7-linux-android9 -mcpu=cortex-a8 | FileCheck %s --check-prefix=SINCOS-GNU +; RUN: llc < %s -mtriple=armv7-linux-android -mcpu=cortex-a8 | FileCheck %s --check-prefix=SINCOS-GNU ; Combine sin / cos into a single call unless they may write errno (as ; captured by readnone attrbiute, controlled by clang -fmath-errno @@ -22,10 +21,6 @@ entry: ; NOOPT: bl _sinf ; NOOPT: bl _cosf -; NOOPT-ANDROID-LABEL: test1: -; NOOPT-ANDROID: bl sinf -; NOOPT-ANDROID: bl cosf - %call = tail call float @sinf(float %x) readnone %call1 = tail call float @cosf(float %x) readnone %add = fadd float %call, %call1 @@ -44,10 +39,6 @@ entry: ; NOOPT: bl _sinf ; NOOPT: bl _cosf -; NOOPT-ANDROID-LABEL: test1_fast: -; NOOPT-ANDROID: bl sinf -; NOOPT-ANDROID: bl cosf - %call = tail call fast float @sinf(float %x) readnone %call1 = tail call fast float @cosf(float %x) readnone %add = fadd float %call, %call1 @@ -68,10 +59,6 @@ entry: ; NOOPT: bl _sinf ; NOOPT: bl _cosf -; NOOPT-ANDROID-LABEL: test1_errno: -; NOOPT-ANDROID: bl sinf -; NOOPT-ANDROID: bl cosf - %call = tail call float @sinf(float %x) %call1 = tail call float @cosf(float %x) %add = fadd float %call, %call1 @@ -90,10 +77,6 @@ entry: ; NOOPT: bl _sin ; NOOPT: bl _cos -; NOOPT-ANDROID-LABEL: test2: -; NOOPT-ANDROID: bl sin -; NOOPT-ANDROID: bl cos - %call = tail call double @sin(double %x) readnone %call1 = tail call double @cos(double %x) readnone %add = fadd double %call, %call1 @@ -112,10 +95,6 @@ entry: ; NOOPT: bl _sin ; NOOPT: bl _cos -; NOOPT-ANDROID-LABEL: test2_fast: -; NOOPT-ANDROID: bl sin -; NOOPT-ANDROID: bl cos - %call = tail call fast double @sin(double %x) readnone %call1 = tail call fast double @cos(double %x) readnone %add = fadd double %call, %call1 @@ -136,10 +115,6 @@ entry: ; NOOPT: bl _sin ; NOOPT: bl _cos -; NOOPT-ANDROID-LABEL: test2_errno: -; NOOPT-ANDROID: bl sin -; NOOPT-ANDROID: bl cos - %call = tail call double @sin(double %x) %call1 = tail call double @cos(double %x) %add = fadd double %call, %call1 diff --git a/llvm/test/CodeGen/RISCV/cmov-branch-opt.ll b/llvm/test/CodeGen/RISCV/cmov-branch-opt.ll index edec1d0..1957019 100644 --- a/llvm/test/CodeGen/RISCV/cmov-branch-opt.ll +++ b/llvm/test/CodeGen/RISCV/cmov-branch-opt.ll @@ -201,8 +201,9 @@ define signext i32 @test4(i32 signext %x, i32 signext %y, i32 signext %z) { ; ; RV32IXQCI-LABEL: test4: ; RV32IXQCI: # %bb.0: -; RV32IXQCI-NEXT: li a0, 0 -; RV32IXQCI-NEXT: qc.lieqi a0, a2, 0, 3 +; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: li a1, 3 +; RV32IXQCI-NEXT: qc.selectieqi a0, 0, a1, 0 ; RV32IXQCI-NEXT: ret %c = icmp eq i32 %z, 0 %a = select i1 %c, i32 3, i32 0 diff --git a/llvm/test/CodeGen/RISCV/xqcicli.ll b/llvm/test/CodeGen/RISCV/xqcicli.ll index 8d4caa1..cdb1947 100644 --- a/llvm/test/CodeGen/RISCV/xqcicli.ll +++ b/llvm/test/CodeGen/RISCV/xqcicli.ll @@ -23,7 +23,8 @@ define i32 @select_cc_example_eq(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eq: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieq a0, a1, a2, 11 +; RV32IXQCI-NEXT: qc.selectine a1, a2, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %b, %x @@ -47,7 +48,8 @@ define i32 @select_cc_example_ne(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ne: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.line a0, a1, a2, 11 +; RV32IXQCI-NEXT: qc.selectieq a1, a2, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %b, %x @@ -167,7 +169,8 @@ define i32 @select_cc_example_eq_c(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eq_c: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.line a0, a1, a2, 11 +; RV32IXQCI-NEXT: qc.selectieq a1, a2, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %b, %x @@ -191,7 +194,8 @@ define i32 @select_cc_example_ne_c(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ne_c: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieq a0, a1, a2, 11 +; RV32IXQCI-NEXT: qc.selectine a1, a2, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %b, %x @@ -312,7 +316,8 @@ define i32 @select_cc_example_eqi(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eqi: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectinei a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %b, 12 @@ -337,7 +342,8 @@ define i32 @select_cc_example_nei(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_nei: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectieqi a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %b, 12 @@ -462,7 +468,8 @@ define i32 @select_cc_example_eqi_c1(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eqi_c1: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectinei a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 12, %b @@ -487,7 +494,8 @@ define i32 @select_cc_example_nei_c1(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_nei_c1: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectieqi a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 12, %b @@ -612,7 +620,8 @@ define i32 @select_cc_example_eqi_c2(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eqi_c2: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectieqi a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 12, %b @@ -637,7 +646,8 @@ define i32 @select_cc_example_nei_c2(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_nei_c2: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectinei a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 12, %b @@ -762,7 +772,8 @@ define i32 @select_cc_example_eqi_c3(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eqi_c3: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectieqi a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %b, 12 @@ -787,7 +798,8 @@ define i32 @select_cc_example_nei_c3(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_nei_c3: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a0, a1, 12, 11 +; RV32IXQCI-NEXT: qc.selectinei a1, 12, a0, 11 +; RV32IXQCI-NEXT: mv a0, a1 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %b, 12 diff --git a/llvm/test/CodeGen/RISCV/xqcics.ll b/llvm/test/CodeGen/RISCV/xqcics.ll index c0839c9..7656a0c 100644 --- a/llvm/test/CodeGen/RISCV/xqcics.ll +++ b/llvm/test/CodeGen/RISCV/xqcics.ll @@ -270,8 +270,7 @@ define i32 @select_cc_example_eqi(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eqi: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.line a2, a0, a1, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieq a0, a1, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %a, %b @@ -301,8 +300,7 @@ define i32 @select_cc_example_eqi_c(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eqi_c: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieq a2, a0, a1, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectine a0, a1, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %a, %b @@ -332,8 +330,7 @@ define i32 @select_cc_example_nei(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_nei: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieq a2, a0, a1, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectine a0, a1, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %a, %b @@ -363,8 +360,7 @@ define i32 @select_cc_example_nei_c(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_nei_c: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.line a2, a0, a1, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieq a0, a1, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %a, %b @@ -395,8 +391,7 @@ define i32 @select_cc_example_ieqi(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ieqi: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieqi a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %a, 12 @@ -427,8 +422,7 @@ define i32 @select_cc_example_ieqi_c1(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ieqi_c1: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieqi a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 12, %a @@ -459,8 +453,7 @@ define i32 @select_cc_example_ieqi_c2(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ieqi_c2: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectinei a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %a, 12 @@ -491,8 +484,7 @@ define i32 @select_cc_example_ieqi_c3(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ieqi_c3: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectinei a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 12, %a @@ -523,8 +515,7 @@ define i32 @select_cc_example_inei(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_inei: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectinei a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %a, 12 @@ -555,8 +546,7 @@ define i32 @select_cc_example_inei_c1(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_inei_c1: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieqi a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectinei a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 12, %a @@ -587,8 +577,7 @@ define i32 @select_cc_example_inei_c2(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_inei_c2: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieqi a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %a, 12 @@ -619,8 +608,7 @@ define i32 @select_cc_example_inei_c3(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_inei_c3: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.linei a2, a0, 12, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieqi a0, 12, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 12, %a @@ -712,8 +700,7 @@ define i32 @select_cc_example_eq1(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_eq1: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.line a2, a1, a0, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectieq a0, a1, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp eq i32 %b, %a @@ -743,8 +730,7 @@ define i32 @select_cc_example_ne1(i32 %a, i32 %b, i32 %x, i32 %y) { ; ; RV32IXQCI-LABEL: select_cc_example_ne1: ; RV32IXQCI: # %bb.0: # %entry -; RV32IXQCI-NEXT: qc.lieq a2, a1, a0, 11 -; RV32IXQCI-NEXT: mv a0, a2 +; RV32IXQCI-NEXT: qc.selectine a0, a1, a2, 11 ; RV32IXQCI-NEXT: ret entry: %cmp = icmp ne i32 %b, %a diff --git a/llvm/test/CodeGen/X86/fast-isel-fneg.ll b/llvm/test/CodeGen/X86/fast-isel-fneg.ll deleted file mode 100644 index 128f5ee..0000000 --- a/llvm/test/CodeGen/X86/fast-isel-fneg.ll +++ /dev/null @@ -1,101 +0,0 @@ -; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py -; RUN: llc < %s -fast-isel -fast-isel-abort=3 -mtriple=x86_64-apple-darwin10 | FileCheck %s -; RUN: llc < %s -fast-isel -mtriple=i686-- -mattr=+sse2 | FileCheck --check-prefix=SSE2 %s - -define double @fneg_f64(double %x) nounwind { -; CHECK-LABEL: fneg_f64: -; CHECK: ## %bb.0: -; CHECK-NEXT: movq %xmm0, %rax -; CHECK-NEXT: movabsq $-9223372036854775808, %rcx ## imm = 0x8000000000000000 -; CHECK-NEXT: xorq %rax, %rcx -; CHECK-NEXT: movq %rcx, %xmm0 -; CHECK-NEXT: retq -; -; SSE2-LABEL: fneg_f64: -; SSE2: # %bb.0: -; SSE2-NEXT: pushl %ebp -; SSE2-NEXT: movl %esp, %ebp -; SSE2-NEXT: andl $-8, %esp -; SSE2-NEXT: subl $8, %esp -; SSE2-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero -; SSE2-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0 -; SSE2-NEXT: movlps %xmm0, (%esp) -; SSE2-NEXT: fldl (%esp) -; SSE2-NEXT: movl %ebp, %esp -; SSE2-NEXT: popl %ebp -; SSE2-NEXT: retl - %y = fneg double %x - ret double %y -} - -define float @fneg_f32(float %x) nounwind { -; CHECK-LABEL: fneg_f32: -; CHECK: ## %bb.0: -; CHECK-NEXT: movd %xmm0, %eax -; CHECK-NEXT: xorl $2147483648, %eax ## imm = 0x80000000 -; CHECK-NEXT: movd %eax, %xmm0 -; CHECK-NEXT: retq -; -; SSE2-LABEL: fneg_f32: -; SSE2: # %bb.0: -; SSE2-NEXT: pushl %eax -; SSE2-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero -; SSE2-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0 -; SSE2-NEXT: movss %xmm0, (%esp) -; SSE2-NEXT: flds (%esp) -; SSE2-NEXT: popl %eax -; SSE2-NEXT: retl - %y = fneg float %x - ret float %y -} - -define void @fneg_f64_mem(ptr %x, ptr %y) nounwind { -; CHECK-LABEL: fneg_f64_mem: -; CHECK: ## %bb.0: -; CHECK-NEXT: movq {{.*#+}} xmm0 = mem[0],zero -; CHECK-NEXT: movq %xmm0, %rax -; CHECK-NEXT: movabsq $-9223372036854775808, %rcx ## imm = 0x8000000000000000 -; CHECK-NEXT: xorq %rax, %rcx -; CHECK-NEXT: movq %rcx, %xmm0 -; CHECK-NEXT: movq %xmm0, (%rsi) -; CHECK-NEXT: retq -; -; SSE2-LABEL: fneg_f64_mem: -; SSE2: # %bb.0: -; SSE2-NEXT: movl {{[0-9]+}}(%esp), %eax -; SSE2-NEXT: movl {{[0-9]+}}(%esp), %ecx -; SSE2-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero -; SSE2-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0 -; SSE2-NEXT: movsd %xmm0, (%eax) -; SSE2-NEXT: retl - %a = load double, ptr %x - %b = fneg double %a - store double %b, ptr %y - ret void -} - -define void @fneg_f32_mem(ptr %x, ptr %y) nounwind { -; CHECK-LABEL: fneg_f32_mem: -; CHECK: ## %bb.0: -; CHECK-NEXT: movd {{.*#+}} xmm0 = mem[0],zero,zero,zero -; CHECK-NEXT: movd %xmm0, %eax -; CHECK-NEXT: xorl $2147483648, %eax ## imm = 0x80000000 -; CHECK-NEXT: movd %eax, %xmm0 -; CHECK-NEXT: movd %xmm0, (%rsi) -; CHECK-NEXT: retq -; -; SSE2-LABEL: fneg_f32_mem: -; SSE2: # %bb.0: -; SSE2-NEXT: movl {{[0-9]+}}(%esp), %eax -; SSE2-NEXT: movl {{[0-9]+}}(%esp), %ecx -; SSE2-NEXT: movd {{.*#+}} xmm0 = mem[0],zero,zero,zero -; SSE2-NEXT: movd %xmm0, %ecx -; SSE2-NEXT: xorl $2147483648, %ecx # imm = 0x80000000 -; SSE2-NEXT: movd %ecx, %xmm0 -; SSE2-NEXT: movd %xmm0, (%eax) -; SSE2-NEXT: retl - %a = load float, ptr %x - %b = fneg float %a - store float %b, ptr %y - ret void -} diff --git a/llvm/test/CodeGen/X86/fp-int-fp-cvt.ll b/llvm/test/CodeGen/X86/fp-int-fp-cvt.ll new file mode 100644 index 0000000..b6c17ce --- /dev/null +++ b/llvm/test/CodeGen/X86/fp-int-fp-cvt.ll @@ -0,0 +1,240 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py +; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=x86-64 | FileCheck %s --check-prefixes=SSE +; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=x86-64-v2 | FileCheck %s --check-prefixes=SSE +; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=x86-64-v3 | FileCheck %s --check-prefixes=AVX,AVX2 +; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=x86-64-v4 | FileCheck %s --check-prefixes=AVX,AVX512,AVX512-VL +; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=x86-64-v4 -mattr=-avx512vl | FileCheck %s --check-prefixes=AVX,AVX512,AVX512-NOVL + +; +; fptosi -> sitofp +; + +define double @scvtf64_i32(double %a0) { +; SSE-LABEL: scvtf64_i32: +; SSE: # %bb.0: +; SSE-NEXT: cvttpd2dq %xmm0, %xmm0 +; SSE-NEXT: cvtdq2pd %xmm0, %xmm0 +; SSE-NEXT: retq +; +; AVX-LABEL: scvtf64_i32: +; AVX: # %bb.0: +; AVX-NEXT: vcvttpd2dq %xmm0, %xmm0 +; AVX-NEXT: vcvtdq2pd %xmm0, %xmm0 +; AVX-NEXT: retq + %ii = fptosi double %a0 to i32 + %ff = sitofp i32 %ii to double + ret double %ff +} + +define double @scvtf64_i64(double %a0) { +; SSE-LABEL: scvtf64_i64: +; SSE: # %bb.0: +; SSE-NEXT: cvttsd2si %xmm0, %rax +; SSE-NEXT: xorps %xmm0, %xmm0 +; SSE-NEXT: cvtsi2sd %rax, %xmm0 +; SSE-NEXT: retq +; +; AVX-LABEL: scvtf64_i64: +; AVX: # %bb.0: +; AVX-NEXT: vcvttsd2si %xmm0, %rax +; AVX-NEXT: vcvtsi2sd %rax, %xmm15, %xmm0 +; AVX-NEXT: retq + %ii = fptosi double %a0 to i64 + %ff = sitofp i64 %ii to double + ret double %ff +} + +define float @scvtf32_i32(float %a0) { +; SSE-LABEL: scvtf32_i32: +; SSE: # %bb.0: +; SSE-NEXT: cvttps2dq %xmm0, %xmm0 +; SSE-NEXT: cvtdq2ps %xmm0, %xmm0 +; SSE-NEXT: retq +; +; AVX-LABEL: scvtf32_i32: +; AVX: # %bb.0: +; AVX-NEXT: vcvttps2dq %xmm0, %xmm0 +; AVX-NEXT: vcvtdq2ps %xmm0, %xmm0 +; AVX-NEXT: retq + %ii = fptosi float %a0 to i32 + %ff = sitofp i32 %ii to float + ret float %ff +} + +define float @scvtf32_i64(float %a0) { +; SSE-LABEL: scvtf32_i64: +; SSE: # %bb.0: +; SSE-NEXT: cvttss2si %xmm0, %rax +; SSE-NEXT: xorps %xmm0, %xmm0 +; SSE-NEXT: cvtsi2ss %rax, %xmm0 +; SSE-NEXT: retq +; +; AVX-LABEL: scvtf32_i64: +; AVX: # %bb.0: +; AVX-NEXT: vcvttss2si %xmm0, %rax +; AVX-NEXT: vcvtsi2ss %rax, %xmm15, %xmm0 +; AVX-NEXT: retq + %ii = fptosi float %a0 to i64 + %ff = sitofp i64 %ii to float + ret float %ff +} + +; +; fptoui -> uitofp +; + +define double @ucvtf64_i32(double %a0) { +; SSE-LABEL: ucvtf64_i32: +; SSE: # %bb.0: +; SSE-NEXT: cvttsd2si %xmm0, %rax +; SSE-NEXT: movl %eax, %eax +; SSE-NEXT: xorps %xmm0, %xmm0 +; SSE-NEXT: cvtsi2sd %rax, %xmm0 +; SSE-NEXT: retq +; +; AVX2-LABEL: ucvtf64_i32: +; AVX2: # %bb.0: +; AVX2-NEXT: vcvttsd2si %xmm0, %rax +; AVX2-NEXT: movl %eax, %eax +; AVX2-NEXT: vcvtsi2sd %rax, %xmm15, %xmm0 +; AVX2-NEXT: retq +; +; AVX512-LABEL: ucvtf64_i32: +; AVX512: # %bb.0: +; AVX512-NEXT: vcvttsd2usi %xmm0, %eax +; AVX512-NEXT: vcvtusi2sd %eax, %xmm15, %xmm0 +; AVX512-NEXT: retq + %ii = fptoui double %a0 to i32 + %ff = uitofp i32 %ii to double + ret double %ff +} + +define double @ucvtf64_i64(double %a0) { +; SSE-LABEL: ucvtf64_i64: +; SSE: # %bb.0: +; SSE-NEXT: cvttsd2si %xmm0, %rax +; SSE-NEXT: movq %rax, %rcx +; SSE-NEXT: subsd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 +; SSE-NEXT: cvttsd2si %xmm0, %rdx +; SSE-NEXT: sarq $63, %rcx +; SSE-NEXT: andq %rcx, %rdx +; SSE-NEXT: orq %rax, %rdx +; SSE-NEXT: movq %rdx, %xmm1 +; SSE-NEXT: punpckldq {{.*#+}} xmm1 = xmm1[0],mem[0],xmm1[1],mem[1] +; SSE-NEXT: subpd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm1 +; SSE-NEXT: movapd %xmm1, %xmm0 +; SSE-NEXT: unpckhpd {{.*#+}} xmm0 = xmm0[1],xmm1[1] +; SSE-NEXT: addsd %xmm1, %xmm0 +; SSE-NEXT: retq +; +; AVX2-LABEL: ucvtf64_i64: +; AVX2: # %bb.0: +; AVX2-NEXT: vcvttsd2si %xmm0, %rax +; AVX2-NEXT: movq %rax, %rcx +; AVX2-NEXT: vsubsd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 +; AVX2-NEXT: sarq $63, %rcx +; AVX2-NEXT: vcvttsd2si %xmm0, %rdx +; AVX2-NEXT: andq %rcx, %rdx +; AVX2-NEXT: orq %rax, %rdx +; AVX2-NEXT: vmovq %rdx, %xmm0 +; AVX2-NEXT: vpunpckldq {{.*#+}} xmm0 = xmm0[0],mem[0],xmm0[1],mem[1] +; AVX2-NEXT: vsubpd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 +; AVX2-NEXT: vshufpd {{.*#+}} xmm1 = xmm0[1,0] +; AVX2-NEXT: vaddsd %xmm0, %xmm1, %xmm0 +; AVX2-NEXT: retq +; +; AVX512-LABEL: ucvtf64_i64: +; AVX512: # %bb.0: +; AVX512-NEXT: vcvttsd2usi %xmm0, %rax +; AVX512-NEXT: vcvtusi2sd %rax, %xmm15, %xmm0 +; AVX512-NEXT: retq + %ii = fptoui double %a0 to i64 + %ff = uitofp i64 %ii to double + ret double %ff +} + +define float @ucvtf32_i32(float %a0) { +; SSE-LABEL: ucvtf32_i32: +; SSE: # %bb.0: +; SSE-NEXT: cvttss2si %xmm0, %rax +; SSE-NEXT: movl %eax, %eax +; SSE-NEXT: xorps %xmm0, %xmm0 +; SSE-NEXT: cvtsi2ss %rax, %xmm0 +; SSE-NEXT: retq +; +; AVX2-LABEL: ucvtf32_i32: +; AVX2: # %bb.0: +; AVX2-NEXT: vcvttss2si %xmm0, %rax +; AVX2-NEXT: movl %eax, %eax +; AVX2-NEXT: vcvtsi2ss %rax, %xmm15, %xmm0 +; AVX2-NEXT: retq +; +; AVX512-LABEL: ucvtf32_i32: +; AVX512: # %bb.0: +; AVX512-NEXT: vcvttss2usi %xmm0, %eax +; AVX512-NEXT: vcvtusi2ss %eax, %xmm15, %xmm0 +; AVX512-NEXT: retq + %ii = fptoui float %a0 to i32 + %ff = uitofp i32 %ii to float + ret float %ff +} + +define float @ucvtf32_i64(float %a0) { +; SSE-LABEL: ucvtf32_i64: +; SSE: # %bb.0: +; SSE-NEXT: cvttss2si %xmm0, %rcx +; SSE-NEXT: movq %rcx, %rdx +; SSE-NEXT: sarq $63, %rdx +; SSE-NEXT: subss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 +; SSE-NEXT: cvttss2si %xmm0, %rax +; SSE-NEXT: andq %rdx, %rax +; SSE-NEXT: orq %rcx, %rax +; SSE-NEXT: js .LBB7_1 +; SSE-NEXT: # %bb.2: +; SSE-NEXT: xorps %xmm0, %xmm0 +; SSE-NEXT: cvtsi2ss %rax, %xmm0 +; SSE-NEXT: retq +; SSE-NEXT: .LBB7_1: +; SSE-NEXT: movq %rax, %rcx +; SSE-NEXT: shrq %rcx +; SSE-NEXT: andl $1, %eax +; SSE-NEXT: orq %rcx, %rax +; SSE-NEXT: xorps %xmm0, %xmm0 +; SSE-NEXT: cvtsi2ss %rax, %xmm0 +; SSE-NEXT: addss %xmm0, %xmm0 +; SSE-NEXT: retq +; +; AVX2-LABEL: ucvtf32_i64: +; AVX2: # %bb.0: +; AVX2-NEXT: vcvttss2si %xmm0, %rcx +; AVX2-NEXT: movq %rcx, %rdx +; AVX2-NEXT: sarq $63, %rdx +; AVX2-NEXT: vsubss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 +; AVX2-NEXT: vcvttss2si %xmm0, %rax +; AVX2-NEXT: andq %rdx, %rax +; AVX2-NEXT: orq %rcx, %rax +; AVX2-NEXT: js .LBB7_1 +; AVX2-NEXT: # %bb.2: +; AVX2-NEXT: vcvtsi2ss %rax, %xmm15, %xmm0 +; AVX2-NEXT: retq +; AVX2-NEXT: .LBB7_1: +; AVX2-NEXT: movq %rax, %rcx +; AVX2-NEXT: shrq %rcx +; AVX2-NEXT: andl $1, %eax +; AVX2-NEXT: orq %rcx, %rax +; AVX2-NEXT: vcvtsi2ss %rax, %xmm15, %xmm0 +; AVX2-NEXT: vaddss %xmm0, %xmm0, %xmm0 +; AVX2-NEXT: retq +; +; AVX512-LABEL: ucvtf32_i64: +; AVX512: # %bb.0: +; AVX512-NEXT: vcvttss2usi %xmm0, %rax +; AVX512-NEXT: vcvtusi2ss %rax, %xmm15, %xmm0 +; AVX512-NEXT: retq + %ii = fptoui float %a0 to i64 + %ff = uitofp i64 %ii to float + ret float %ff +} +;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: +; AVX512-NOVL: {{.*}} +; AVX512-VL: {{.*}} diff --git a/llvm/test/CodeGen/X86/isel-fneg.ll b/llvm/test/CodeGen/X86/isel-fneg.ll new file mode 100644 index 0000000..77b3f26 --- /dev/null +++ b/llvm/test/CodeGen/X86/isel-fneg.ll @@ -0,0 +1,208 @@ +; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6 +; RUN: llc < %s -mtriple=i686-linux-gnu -fast-isel | FileCheck %s --check-prefixes=X86,FASTISEL-X86 +; RUN: llc < %s -mtriple=i686-linux-gnu -global-isel=0 -fast-isel=0 | FileCheck %s --check-prefixes=X86,SDAG-X86 +; DISABLED: llc < %s -mtriple=i686-linux-gnu -global-isel=1 -global-isel-abort=2 | FileCheck %s --check-prefixes=X86,GISEL-X86 +; RUN: llc < %s -mtriple=i686-linux-gnu -fast-isel -mattr=+sse | FileCheck %s --check-prefixes=X86,SSE-X86,FASTISEL-SSE-X86 +; RUN: llc < %s -mtriple=i686-linux-gnu -global-isel=0 -fast-isel=0 -mattr=+sse | FileCheck %s --check-prefixes=X86,SSE-X86,SDAG-SSE-X86 +; DISABLED: llc < %s -mtriple=i686-linux-gnu -global-isel=1 -global-isel-abort=2 -mattr=+sse | FileCheck %s --check-prefixes=X86,SSE-X86,GISEL-SSE-X86 +; RUN: llc < %s -mtriple=x86_64-linux-gnu -fast-isel -mattr=+sse | FileCheck %s --check-prefixes=X64,SSE-X64,FASTISEL-SSE-X64 +; RUN: llc < %s -mtriple=x86_64-linux-gnu -global-isel=0 -fast-isel=0 -mattr=+sse | FileCheck %s --check-prefixes=X64,SSE-X64,SDAG-SSE-X64 +; RUN: llc < %s -mtriple=x86_64-linux-gnu -global-isel=1 -global-isel-abort=2 -mattr=+sse | FileCheck %s --check-prefixes=X64,SSE-X64,GISEL-SSE-X64 + +define double @fneg_f64(double %x) nounwind { +; X86-LABEL: fneg_f64: +; X86: # %bb.0: +; X86-NEXT: fldl {{[0-9]+}}(%esp) +; X86-NEXT: fchs +; X86-NEXT: retl +; +; FASTISEL-SSE-X64-LABEL: fneg_f64: +; FASTISEL-SSE-X64: # %bb.0: +; FASTISEL-SSE-X64-NEXT: movq %xmm0, %rax +; FASTISEL-SSE-X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000 +; FASTISEL-SSE-X64-NEXT: xorq %rax, %rcx +; FASTISEL-SSE-X64-NEXT: movq %rcx, %xmm0 +; FASTISEL-SSE-X64-NEXT: retq +; +; SDAG-SSE-X64-LABEL: fneg_f64: +; SDAG-SSE-X64: # %bb.0: +; SDAG-SSE-X64-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 +; SDAG-SSE-X64-NEXT: retq +; +; GISEL-SSE-X64-LABEL: fneg_f64: +; GISEL-SSE-X64: # %bb.0: +; GISEL-SSE-X64-NEXT: movabsq $-9223372036854775808, %rax # imm = 0x8000000000000000 +; GISEL-SSE-X64-NEXT: movq %xmm0, %rcx +; GISEL-SSE-X64-NEXT: xorq %rax, %rcx +; GISEL-SSE-X64-NEXT: movq %rcx, %xmm0 +; GISEL-SSE-X64-NEXT: retq + %y = fneg double %x + ret double %y +} + +define float @fneg_f32(float %x) nounwind { +; FASTISEL-X86-LABEL: fneg_f32: +; FASTISEL-X86: # %bb.0: +; FASTISEL-X86-NEXT: flds {{[0-9]+}}(%esp) +; FASTISEL-X86-NEXT: fchs +; FASTISEL-X86-NEXT: retl +; +; SDAG-X86-LABEL: fneg_f32: +; SDAG-X86: # %bb.0: +; SDAG-X86-NEXT: flds {{[0-9]+}}(%esp) +; SDAG-X86-NEXT: fchs +; SDAG-X86-NEXT: retl +; +; SSE-X86-LABEL: fneg_f32: +; SSE-X86: # %bb.0: +; SSE-X86-NEXT: pushl %eax +; SSE-X86-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero +; SSE-X86-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0 +; SSE-X86-NEXT: movss %xmm0, (%esp) +; SSE-X86-NEXT: flds (%esp) +; SSE-X86-NEXT: popl %eax +; SSE-X86-NEXT: retl +; +; FASTISEL-SSE-X64-LABEL: fneg_f32: +; FASTISEL-SSE-X64: # %bb.0: +; FASTISEL-SSE-X64-NEXT: movd %xmm0, %eax +; FASTISEL-SSE-X64-NEXT: xorl $2147483648, %eax # imm = 0x80000000 +; FASTISEL-SSE-X64-NEXT: movd %eax, %xmm0 +; FASTISEL-SSE-X64-NEXT: retq +; +; SDAG-SSE-X64-LABEL: fneg_f32: +; SDAG-SSE-X64: # %bb.0: +; SDAG-SSE-X64-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0 +; SDAG-SSE-X64-NEXT: retq +; +; GISEL-SSE-X64-LABEL: fneg_f32: +; GISEL-SSE-X64: # %bb.0: +; GISEL-SSE-X64-NEXT: movd %xmm0, %eax +; GISEL-SSE-X64-NEXT: addl $-2147483648, %eax # imm = 0x80000000 +; GISEL-SSE-X64-NEXT: movd %eax, %xmm0 +; GISEL-SSE-X64-NEXT: retq + %y = fneg float %x + ret float %y +} + +define void @fneg_f64_mem(ptr %x, ptr %y) nounwind { +; X86-LABEL: fneg_f64_mem: +; X86: # %bb.0: +; X86-NEXT: movl {{[0-9]+}}(%esp), %eax +; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx +; X86-NEXT: fldl (%ecx) +; X86-NEXT: fchs +; X86-NEXT: fstpl (%eax) +; X86-NEXT: retl +; +; FASTISEL-SSE-X64-LABEL: fneg_f64_mem: +; FASTISEL-SSE-X64: # %bb.0: +; FASTISEL-SSE-X64-NEXT: movq {{.*#+}} xmm0 = mem[0],zero +; FASTISEL-SSE-X64-NEXT: movq %xmm0, %rax +; FASTISEL-SSE-X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000 +; FASTISEL-SSE-X64-NEXT: xorq %rax, %rcx +; FASTISEL-SSE-X64-NEXT: movq %rcx, %xmm0 +; FASTISEL-SSE-X64-NEXT: movq %xmm0, (%rsi) +; FASTISEL-SSE-X64-NEXT: retq +; +; SDAG-SSE-X64-LABEL: fneg_f64_mem: +; SDAG-SSE-X64: # %bb.0: +; SDAG-SSE-X64-NEXT: movabsq $-9223372036854775808, %rax # imm = 0x8000000000000000 +; SDAG-SSE-X64-NEXT: xorq (%rdi), %rax +; SDAG-SSE-X64-NEXT: movq %rax, (%rsi) +; SDAG-SSE-X64-NEXT: retq +; +; GISEL-SSE-X64-LABEL: fneg_f64_mem: +; GISEL-SSE-X64: # %bb.0: +; GISEL-SSE-X64-NEXT: movabsq $-9223372036854775808, %rax # imm = 0x8000000000000000 +; GISEL-SSE-X64-NEXT: xorq (%rdi), %rax +; GISEL-SSE-X64-NEXT: movq %rax, (%rsi) +; GISEL-SSE-X64-NEXT: retq + %a = load double, ptr %x + %b = fneg double %a + store double %b, ptr %y + ret void +} + +define void @fneg_f32_mem(ptr %x, ptr %y) nounwind { +; FASTISEL-X86-LABEL: fneg_f32_mem: +; FASTISEL-X86: # %bb.0: +; FASTISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %eax +; FASTISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx +; FASTISEL-X86-NEXT: movl $-2147483648, %edx # imm = 0x80000000 +; FASTISEL-X86-NEXT: xorl (%ecx), %edx +; FASTISEL-X86-NEXT: movl %edx, (%eax) +; FASTISEL-X86-NEXT: retl +; +; SDAG-X86-LABEL: fneg_f32_mem: +; SDAG-X86: # %bb.0: +; SDAG-X86-NEXT: movl {{[0-9]+}}(%esp), %eax +; SDAG-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx +; SDAG-X86-NEXT: movl $-2147483648, %edx # imm = 0x80000000 +; SDAG-X86-NEXT: xorl (%ecx), %edx +; SDAG-X86-NEXT: movl %edx, (%eax) +; SDAG-X86-NEXT: retl +; +; FASTISEL-SSE-X86-LABEL: fneg_f32_mem: +; FASTISEL-SSE-X86: # %bb.0: +; FASTISEL-SSE-X86-NEXT: movl {{[0-9]+}}(%esp), %eax +; FASTISEL-SSE-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx +; FASTISEL-SSE-X86-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero +; FASTISEL-SSE-X86-NEXT: xorps {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0 +; FASTISEL-SSE-X86-NEXT: movss %xmm0, (%eax) +; FASTISEL-SSE-X86-NEXT: retl +; +; SDAG-SSE-X86-LABEL: fneg_f32_mem: +; SDAG-SSE-X86: # %bb.0: +; SDAG-SSE-X86-NEXT: movl {{[0-9]+}}(%esp), %eax +; SDAG-SSE-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx +; SDAG-SSE-X86-NEXT: movl $-2147483648, %edx # imm = 0x80000000 +; SDAG-SSE-X86-NEXT: xorl (%ecx), %edx +; SDAG-SSE-X86-NEXT: movl %edx, (%eax) +; SDAG-SSE-X86-NEXT: retl +; +; FASTISEL-SSE-X64-LABEL: fneg_f32_mem: +; FASTISEL-SSE-X64: # %bb.0: +; FASTISEL-SSE-X64-NEXT: movd {{.*#+}} xmm0 = mem[0],zero,zero,zero +; FASTISEL-SSE-X64-NEXT: movd %xmm0, %eax +; FASTISEL-SSE-X64-NEXT: xorl $2147483648, %eax # imm = 0x80000000 +; FASTISEL-SSE-X64-NEXT: movd %eax, %xmm0 +; FASTISEL-SSE-X64-NEXT: movd %xmm0, (%rsi) +; FASTISEL-SSE-X64-NEXT: retq +; +; SDAG-SSE-X64-LABEL: fneg_f32_mem: +; SDAG-SSE-X64: # %bb.0: +; SDAG-SSE-X64-NEXT: movl $-2147483648, %eax # imm = 0x80000000 +; SDAG-SSE-X64-NEXT: xorl (%rdi), %eax +; SDAG-SSE-X64-NEXT: movl %eax, (%rsi) +; SDAG-SSE-X64-NEXT: retq +; +; GISEL-SSE-X64-LABEL: fneg_f32_mem: +; GISEL-SSE-X64: # %bb.0: +; GISEL-SSE-X64-NEXT: movl $-2147483648, %eax # imm = 0x80000000 +; GISEL-SSE-X64-NEXT: xorl (%rdi), %eax +; GISEL-SSE-X64-NEXT: movl %eax, (%rsi) +; GISEL-SSE-X64-NEXT: retq + %a = load float, ptr %x + %b = fneg float %a + store float %b, ptr %y + ret void +} + +define x86_fp80 @test_fp80(x86_fp80 %a) nounwind { +; X86-LABEL: test_fp80: +; X86: # %bb.0: +; X86-NEXT: fldt {{[0-9]+}}(%esp) +; X86-NEXT: fchs +; X86-NEXT: retl +; +; X64-LABEL: test_fp80: +; X64: # %bb.0: +; X64-NEXT: fldt {{[0-9]+}}(%rsp) +; X64-NEXT: fchs +; X64-NEXT: retq + %1 = fneg x86_fp80 %a + ret x86_fp80 %1 +} +;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: +; SSE-X64: {{.*}} diff --git a/llvm/test/CodeGen/X86/stack-protector-target.ll b/llvm/test/CodeGen/X86/stack-protector-target.ll index f7c5680..4ba0302 100644 --- a/llvm/test/CodeGen/X86/stack-protector-target.ll +++ b/llvm/test/CodeGen/X86/stack-protector-target.ll @@ -2,13 +2,8 @@ ; RUN: llc -mtriple=i386-linux < %s -o - | FileCheck --check-prefix=I386-TLS %s ; RUN: llc -mtriple=x86_64-linux < %s -o - | FileCheck --check-prefix=X64-TLS %s -; RUN: llc -mtriple=i386-linux-android < %s -o - | FileCheck --check-prefix=I386 %s -; RUN: llc -mtriple=i386-linux-android16 < %s -o - | FileCheck --check-prefix=I386 %s -; RUN: llc -mtriple=i386-linux-android17 < %s -o - | FileCheck --check-prefix=I386-TLS %s -; RUN: llc -mtriple=i386-linux-android24 < %s -o - | FileCheck --check-prefix=I386-TLS %s +; RUN: llc -mtriple=i386-linux-android < %s -o - | FileCheck --check-prefix=I386-TLS %s ; RUN: llc -mtriple=x86_64-linux-android < %s -o - | FileCheck --check-prefix=X64-TLS %s -; RUN: llc -mtriple=x86_64-linux-android17 < %s -o - | FileCheck --check-prefix=X64-TLS %s -; RUN: llc -mtriple=x86_64-linux-android24 < %s -o - | FileCheck --check-prefix=X64-TLS %s ; RUN: llc -mtriple=i386-kfreebsd < %s -o - | FileCheck --check-prefix=I386-TLS %s ; RUN: llc -mtriple=x86_64-kfreebsd < %s -o - | FileCheck --check-prefix=X64-TLS %s @@ -27,11 +22,6 @@ declare void @_Z7CapturePi(ptr) ; X64-TLS: movq %fs:40, %[[C:.*]] ; X64-TLS: cmpq 16(%rsp), %[[C]] -; I386: movl __stack_chk_guard, %[[B:.*]] -; I386: movl %[[B]], 8(%esp) -; I386: movl __stack_chk_guard, %[[C:.*]] -; I386: cmpl 8(%esp), %[[C]] - ; I386-TLS: movl %gs:20, %[[B:.*]] ; I386-TLS: movl %[[B]], 8(%esp) ; I386-TLS: movl %gs:20, %[[C:.*]] diff --git a/llvm/test/DebugInfo/X86/DW_OP_LLVM_extract_bits.ll b/llvm/test/DebugInfo/X86/DW_OP_LLVM_extract_bits.ll index 8342d42..5928127 100644 --- a/llvm/test/DebugInfo/X86/DW_OP_LLVM_extract_bits.ll +++ b/llvm/test/DebugInfo/X86/DW_OP_LLVM_extract_bits.ll @@ -67,6 +67,8 @@ entry: ; CHECK: DW_TAG_variable ; CHECK: DW_AT_location (DW_OP_fbreg -4, DW_OP_plus_uconst 0x3, DW_OP_deref_size 0x1, DW_OP_constu 0x38, DW_OP_shl, DW_OP_constu 0x39, DW_OP_shr, DW_OP_stack_value) ; CHECK: DW_AT_name ("z") +; CHECK: DW_AT_location (DW_OP_fbreg -4, DW_OP_deref_size 0x8, DW_OP_stack_value) +; CHECK: DW_AT_name ("q") define i32 @test4() !dbg !28 { entry: @@ -74,6 +76,7 @@ entry: tail call void @llvm.dbg.declare(metadata ptr %0, metadata !29, metadata !DIExpression(DW_OP_LLVM_extract_bits_zext, 31, 1)), !dbg !30 tail call void @llvm.dbg.declare(metadata ptr %0, metadata !31, metadata !DIExpression(DW_OP_LLVM_extract_bits_sext, 1, 31)), !dbg !30 tail call void @llvm.dbg.declare(metadata ptr %0, metadata !32, metadata !DIExpression(DW_OP_plus_uconst, 3, DW_OP_LLVM_extract_bits_zext, 1, 7)), !dbg !30 + tail call void @llvm.dbg.declare(metadata ptr %0, metadata !33, metadata !DIExpression(DW_OP_LLVM_extract_bits_zext, 0, 64)), !dbg !30 ret i32 0, !dbg !30 } @@ -116,3 +119,5 @@ declare void @llvm.dbg.value(metadata, metadata, metadata) !30 = !DILocation(line: 0, scope: !28) !31 = !DILocalVariable(name: "y", scope: !28, file: !3, type: !19) !32 = !DILocalVariable(name: "z", scope: !28, file: !3, type: !9) +!33 = !DILocalVariable(name: "q", scope: !28, file: !3, type: !34) +!34 = !DIBasicType(name: "uint64_t", size: 64, encoding: DW_ATE_unsigned) diff --git a/llvm/test/Instrumentation/AddressSanitizer/with-ifunc.ll b/llvm/test/Instrumentation/AddressSanitizer/with-ifunc.ll index f198fc0..659d6aa 100644 --- a/llvm/test/Instrumentation/AddressSanitizer/with-ifunc.ll +++ b/llvm/test/Instrumentation/AddressSanitizer/with-ifunc.ll @@ -4,13 +4,10 @@ ; RUN: opt -passes=asan -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC ; RUN: opt -passes=asan -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=1 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC-NOREMAT -; Pre-Lollipop Android does not support ifunc. -; RUN: opt -passes=asan -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android20 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-NOIFUNC -; RUN: opt -passes=asan -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android < %s | FileCheck %s --check-prefixes=CHECK,CHECK-NOIFUNC -; RUN: opt -passes=asan -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android21 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC +; RUN: opt -passes=asan -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android < %s | FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" -target triple = "armv7--linux-android22" +target triple = "armv7--linux-android" ; CHECK-IFUNC: @__asan_shadow = external global [0 x i8] ; CHECK-NOIFUNC: @__asan_shadow_memory_dynamic_address = external global i32 diff --git a/llvm/test/MC/Mips/branch-pseudos-bad.s b/llvm/test/MC/Mips/branch-pseudos-bad.s index c23164d..9633414 100644 --- a/llvm/test/MC/Mips/branch-pseudos-bad.s +++ b/llvm/test/MC/Mips/branch-pseudos-bad.s @@ -1,5 +1,13 @@ # RUN: not llvm-mc %s -triple=mips -mcpu=mips32 2>&1 | FileCheck %s +# CHECK: error: invalid operand for instruction + beql $t0, ($t0), 1 +# CHECK: error: invalid operand for instruction + bne $t0, ($t0), 1 +# CHECK: error: invalid operand for instruction + beq $t0, ($t0), 1 + + # Check for errors when using conditional branch pseudos after .set noat. .set noat local_label: diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td b/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td index 98a376b..2904474 100644 --- a/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td +++ b/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td @@ -48,6 +48,11 @@ def MSP430LibraryWithCondCC : SystemRuntimeLibrary<isMSP430, // CHECK-NEXT: Entry = DefaultCC; // CHECK-NEXT: } // CHECK-EMPTY: +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x0000000000001a +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: // CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { // CHECK-NEXT: {RTLIB::MALLOC, RTLIB::impl_malloc}, // malloc // CHECK-NEXT: }; @@ -70,9 +75,14 @@ def MSP430LibraryWithCondCC : SystemRuntimeLibrary<isMSP430, // CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: if (TT.getArch() == Triple::avr) { -// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { -// CHECK-NEXT: {RTLIB::MALLOC, RTLIB::impl_malloc}, // malloc -// CHECK-NEXT: }; +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x0000000000001a +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: +// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { +// CHECK-NEXT: {RTLIB::MALLOC, RTLIB::impl_malloc}, // malloc +// CHECK-NEXT: }; // CHECK-EMPTY: // CHECK-NEXT: for (const auto [Func, Impl] : LibraryCalls) { // CHECK-NEXT: setLibcallImpl(Func, Impl); @@ -92,6 +102,11 @@ def MSP430LibraryWithCondCC : SystemRuntimeLibrary<isMSP430, // CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: if (TT.getArch() == Triple::msp430) { +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x00000000000010 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: // CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { // CHECK-NEXT: {RTLIB::MALLOC, RTLIB::impl_malloc}, // malloc // CHECK-NEXT: }; diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td b/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td index 136c81b..f9a148a 100644 --- a/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td +++ b/llvm/test/TableGen/RuntimeLibcallEmitter-conflict-warning.td @@ -25,9 +25,22 @@ def dup1 : RuntimeLibcallImpl<ANOTHER_DUP>; // func_a and func_b both provide SOME_FUNC. // CHECK: if (isTargetArchA()) { -// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { -// CHECK-NEXT: {RTLIB::SOME_FUNC, RTLIB::impl_func_b}, // func_b -// CHECK-NEXT: }; +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x00000000000018 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: + +// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { +// CHECK-NEXT: {RTLIB::SOME_FUNC, RTLIB::impl_func_b}, // func_b +// CHECK-NEXT: }; +// CHECK-EMPTY: +// CHECK-NEXT: for (const auto [Func, Impl] : LibraryCalls) { +// CHECK-NEXT: setLibcallImpl(Func, Impl); +// CHECK-NEXT: } +// CHECK-EMPTY: +// CHECK-NEXT: return; +// CHECK-NEXT: } // ERR: :[[@LINE+1]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_b, func_a def TheSystemLibraryA : SystemRuntimeLibrary<isTargetArchA, @@ -35,10 +48,22 @@ def TheSystemLibraryA : SystemRuntimeLibrary<isTargetArchA, >; // CHECK: if (isTargetArchB()) { -// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { -// CHECK-NEXT: {RTLIB::OTHER_FUNC, RTLIB::impl_other_func}, // other_func -// CHECK-NEXT: {RTLIB::SOME_FUNC, RTLIB::impl_func_a}, // func_a -// CHECK-NEXT: }; +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x00000000000058 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: +// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { +// CHECK-NEXT: {RTLIB::OTHER_FUNC, RTLIB::impl_other_func}, // other_func +// CHECK-NEXT: {RTLIB::SOME_FUNC, RTLIB::impl_func_a}, // func_a +// CHECK-NEXT: }; +// CHECK-EMPTY: +// CHECK-NEXT: for (const auto [Func, Impl] : LibraryCalls) { +// CHECK-NEXT: setLibcallImpl(Func, Impl); +// CHECK-NEXT: } +// CHECK-EMPTY: +// CHECK-NEXT: return; +// CHECK-NEXT: } // ERR: :[[@LINE+1]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_a, func_b def TheSystemLibraryB : SystemRuntimeLibrary<isTargetArchB, @@ -46,11 +71,23 @@ def TheSystemLibraryB : SystemRuntimeLibrary<isTargetArchB, >; // CHECK: if (isTargetArchC()) { -// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { -// CHECK-NEXT: {RTLIB::ANOTHER_DUP, RTLIB::impl_dup1}, // dup1 -// CHECK-NEXT: {RTLIB::OTHER_FUNC, RTLIB::impl_other_func}, // other_func -// CHECK-NEXT: {RTLIB::SOME_FUNC, RTLIB::impl_func_a}, // func_a -// CHECK-NEXT: }; +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x0000000000007e +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: +// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { +// CHECK-NEXT: {RTLIB::ANOTHER_DUP, RTLIB::impl_dup1}, // dup1 +// CHECK-NEXT: {RTLIB::OTHER_FUNC, RTLIB::impl_other_func}, // other_func +// CHECK-NEXT: {RTLIB::SOME_FUNC, RTLIB::impl_func_a}, // func_a +// CHECK-NEXT: }; +// CHECK-EMPTY: +// CHECK-NEXT: for (const auto [Func, Impl] : LibraryCalls) { +// CHECK-NEXT: setLibcallImpl(Func, Impl); +// CHECK-NEXT: } +// CHECK-EMPTY: +// CHECK-NEXT: return; +// CHECK-NEXT: } // ERR: :[[@LINE+3]]:5: warning: conflicting implementations for libcall ANOTHER_DUP: dup1, dup0 // ERR: :[[@LINE+2]]:5: warning: conflicting implementations for libcall SOME_FUNC: func_a, func_b diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter.td b/llvm/test/TableGen/RuntimeLibcallEmitter.td index c336fee..0c23e3b 100644 --- a/llvm/test/TableGen/RuntimeLibcallEmitter.td +++ b/llvm/test/TableGen/RuntimeLibcallEmitter.td @@ -196,15 +196,20 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add calloc, LibraryWithCondi // CHECK-NEXT: }; // CHECK-EMPTY: // CHECK-NEXT: if (TT.getArch() == Triple::blah) { -// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { -// CHECK-NEXT: {RTLIB::BZERO, RTLIB::impl_bzero}, // bzero -// CHECK-NEXT: {RTLIB::CALLOC, RTLIB::impl_calloc}, // calloc -// CHECK-NEXT: {RTLIB::SQRT_F128, RTLIB::impl_sqrtl_f128}, // sqrtl -// CHECK-NEXT: }; +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x000000000000e0 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; // CHECK-EMPTY: -// CHECK-NEXT: for (const auto [Func, Impl] : LibraryCalls) { -// CHECK-NEXT: setLibcallImpl(Func, Impl); -// CHECK-NEXT: } +// CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { +// CHECK-NEXT: {RTLIB::BZERO, RTLIB::impl_bzero}, // bzero +// CHECK-NEXT: {RTLIB::CALLOC, RTLIB::impl_calloc}, // calloc +// CHECK-NEXT: {RTLIB::SQRT_F128, RTLIB::impl_sqrtl_f128}, // sqrtl +// CHECK-NEXT: }; +// CHECK-EMPTY: +// CHECK-NEXT: for (const auto [Func, Impl] : LibraryCalls) { +// CHECK-NEXT: setLibcallImpl(Func, Impl); +// CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: if (TT.hasCompilerRT()) { // CHECK-NEXT: static const LibcallImplPair LibraryCalls_hasCompilerRT[] = { @@ -233,6 +238,11 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add calloc, LibraryWithCondi // CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: if (TT.getArch() == Triple::buzz) { +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x00000000000118 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: // CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { // CHECK-NEXT: {RTLIB::SHL_I32, RTLIB::impl___ashlsi3}, // __ashlsi3 // CHECK-NEXT: {RTLIB::SQRT_F80, RTLIB::impl_sqrtl_f80}, // sqrtl @@ -247,6 +257,11 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add calloc, LibraryWithCondi // CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: if (TT.getArch() == Triple::foo) { +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x000000000000a0 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: // CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { // CHECK-NEXT: {RTLIB::BZERO, RTLIB::impl_bzero}, // bzero // CHECK-NEXT: {RTLIB::SQRT_F128, RTLIB::impl_sqrtl_f128}, // sqrtl @@ -271,6 +286,11 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add calloc, LibraryWithCondi // CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: if (TT.getArch() == Triple::simple) { +// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({ +// CHECK-NEXT: 0x00000000000158 +// CHECK-NEXT: }); +// CHECK-NEXT: AvailableLibcallImpls = SystemAvailableImpls; +// CHECK-EMPTY: // CHECK-NEXT: static const LibcallImplPair LibraryCalls[] = { // CHECK-NEXT: {RTLIB::CALLOC, RTLIB::impl_calloc}, // calloc // CHECK-NEXT: {RTLIB::SHL_I32, RTLIB::impl___ashlsi3}, // __ashlsi3 diff --git a/llvm/test/Transforms/CodeGenPrepare/X86/baseoffs-sext-bug.ll b/llvm/test/Transforms/CodeGenPrepare/X86/baseoffs-sext-bug.ll new file mode 100644 index 0000000..51a461e --- /dev/null +++ b/llvm/test/Transforms/CodeGenPrepare/X86/baseoffs-sext-bug.ll @@ -0,0 +1,81 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6 +; RUN: opt -S -passes='require<profile-summary>,function(codegenprepare)' < %s | FileCheck --check-prefix=GEP %s +; RUN: opt -S -passes='require<profile-summary>,function(codegenprepare)' -addr-sink-using-gep=false < %s | FileCheck --check-prefix=NO-GEP %s + +target triple = "x86_64--linux-gnu" +target datalayout = "e-m:e-p0:128:128-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128" +; -p0:128:128 is added to ensure that transformation will be triggered. + +define i128 @test(i128 %arg) { +; GEP-LABEL: define i128 @test( +; GEP-SAME: i128 [[ARG:%.*]]) { +; GEP-NEXT: [[ENTRY:.*]]: +; GEP-NEXT: [[CMP:%.*]] = icmp ugt i128 [[ARG]], 10 +; GEP-NEXT: br i1 [[CMP]], label %[[THEN:.*]], label %[[EXIT:.*]] +; GEP: [[THEN]]: +; GEP-NEXT: [[SUNKADDR:%.*]] = inttoptr i128 [[ARG]] to ptr +; GEP-NEXT: [[SUNKADDR1:%.*]] = getelementptr i8, ptr [[SUNKADDR]], i128 -32 +; GEP-NEXT: [[LOAD:%.*]] = load i128, ptr [[SUNKADDR1]], align 16 +; GEP-NEXT: br label %[[EXIT]] +; GEP: [[EXIT]]: +; GEP-NEXT: [[PHI:%.*]] = phi i128 [ [[LOAD]], %[[THEN]] ], [ 0, %[[ENTRY]] ] +; GEP-NEXT: ret i128 [[PHI]] +; +; NO-GEP-LABEL: define i128 @test( +; NO-GEP-SAME: i128 [[ARG:%.*]]) { +; NO-GEP-NEXT: [[ENTRY:.*]]: +; NO-GEP-NEXT: [[CMP:%.*]] = icmp ugt i128 [[ARG]], 10 +; NO-GEP-NEXT: br i1 [[CMP]], label %[[THEN:.*]], label %[[EXIT:.*]] +; NO-GEP: [[THEN]]: +; NO-GEP-NEXT: [[SUNKADDR:%.*]] = add i128 [[ARG]], -32 +; NO-GEP-NEXT: [[SUNKADDR1:%.*]] = inttoptr i128 [[SUNKADDR]] to ptr +; NO-GEP-NEXT: [[LOAD:%.*]] = load i128, ptr [[SUNKADDR1]], align 16 +; NO-GEP-NEXT: br label %[[EXIT]] +; NO-GEP: [[EXIT]]: +; NO-GEP-NEXT: [[PHI:%.*]] = phi i128 [ [[LOAD]], %[[THEN]] ], [ 0, %[[ENTRY]] ] +; NO-GEP-NEXT: ret i128 [[PHI]] +; +entry: + %add = add i128 %arg, -32 + %cmp = icmp ugt i128 %arg, 10 + br i1 %cmp, label %then, label %exit + +then: + %inttoptr = inttoptr i128 %add to ptr + %load = load i128, ptr %inttoptr, align 16 + br label %exit + +exit: + %phi = phi i128 [ %load, %then ], [ 0, %entry ] + ret i128 %phi +} + +define void @test_combine(ptr %ptr, i128 %arg) { +; GEP-LABEL: define void @test_combine( +; GEP-SAME: ptr [[PTR:%.*]], i128 [[ARG:%.*]]) { +; GEP-NEXT: [[ENTRY:.*:]] +; GEP-NEXT: [[CMP:%.*]] = icmp ugt i128 [[ARG]], 10 +; GEP-NEXT: [[SELECT1:%.*]] = select i1 [[CMP]], i128 -32, i128 0 +; GEP-NEXT: [[SUNKADDR:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i128 [[SELECT1]] +; GEP-NEXT: store i128 1, ptr [[SUNKADDR]], align 16 +; GEP-NEXT: ret void +; +; NO-GEP-LABEL: define void @test_combine( +; NO-GEP-SAME: ptr [[PTR:%.*]], i128 [[ARG:%.*]]) { +; NO-GEP-NEXT: [[ENTRY:.*:]] +; NO-GEP-NEXT: [[CMP:%.*]] = icmp ugt i128 [[ARG]], 10 +; NO-GEP-NEXT: [[SELECT1:%.*]] = select i1 [[CMP]], i128 -32, i128 0 +; NO-GEP-NEXT: [[SUNKADDR:%.*]] = ptrtoint ptr [[PTR]] to i128 +; NO-GEP-NEXT: [[SUNKADDR2:%.*]] = add i128 [[SUNKADDR]], [[SELECT1]] +; NO-GEP-NEXT: [[SUNKADDR3:%.*]] = inttoptr i128 [[SUNKADDR2]] to ptr +; NO-GEP-NEXT: store i128 1, ptr [[SUNKADDR3]], align 16 +; NO-GEP-NEXT: ret void +; +entry: + %cmp = icmp ugt i128 %arg, 10 + %gep = getelementptr inbounds i8, ptr %ptr, i128 -32 + %select = select i1 %cmp, ptr %gep, ptr %ptr + store i128 1, ptr %select, align 16 + ret void +} + diff --git a/llvm/test/Transforms/DFAJumpThreading/dfa-unfold-select.ll b/llvm/test/Transforms/DFAJumpThreading/dfa-unfold-select.ll index 663f459..de38752 100644 --- a/llvm/test/Transforms/DFAJumpThreading/dfa-unfold-select.ll +++ b/llvm/test/Transforms/DFAJumpThreading/dfa-unfold-select.ll @@ -227,10 +227,6 @@ define i32 @test3(i32 %num) { ; CHECK-NEXT: i32 1, label [[CASE1:%.*]] ; CHECK-NEXT: i32 2, label [[CASE2:%.*]] ; CHECK-NEXT: ] -; CHECK: for.body.jt4: -; CHECK-NEXT: [[COUNT_JT4:%.*]] = phi i32 [ [[INC_JT4:%.*]], [[FOR_INC_JT4:%.*]] ] -; CHECK-NEXT: [[STATE_JT4:%.*]] = phi i32 [ [[STATE_NEXT_JT4:%.*]], [[FOR_INC_JT4]] ] -; CHECK-NEXT: br label [[FOR_INC_JT1]] ; CHECK: for.body.jt3: ; CHECK-NEXT: [[COUNT_JT3:%.*]] = phi i32 [ [[INC_JT3:%.*]], [[FOR_INC_JT3:%.*]] ] ; CHECK-NEXT: [[STATE_JT3:%.*]] = phi i32 [ [[STATE_NEXT_JT3:%.*]], [[FOR_INC_JT3]] ] @@ -261,17 +257,14 @@ define i32 @test3(i32 %num) { ; CHECK: sel.2.si.unfold.false: ; CHECK-NEXT: [[DOTSI_UNFOLD_PHI1:%.*]] = phi i32 [ 4, [[SEL_2_SI_UNFOLD_TRUE_JT3]] ] ; CHECK-NEXT: br label [[SEL_3_SI_UNFOLD_FALSE]] -; CHECK: sel.2.si.unfold.false.jt4: +; CHECK: sel.2.si.unfold.false.jt3: ; CHECK-NEXT: [[DOTSI_UNFOLD_PHI1_JT4:%.*]] = phi i32 [ 4, [[SEL_2_SI_UNFOLD_TRUE:%.*]] ] -; CHECK-NEXT: br label [[SEL_3_SI_UNFOLD_FALSE_JT4:%.*]] +; CHECK-NEXT: br label [[SEL_3_SI_UNFOLD_FALSE_JT3]] ; CHECK: sel.3.si.unfold.false: ; CHECK-NEXT: [[SEL_2_SI_UNFOLD_PHI:%.*]] = phi i32 [ poison, [[SEL_2_SI_UNFOLD_TRUE]] ], [ [[DOTSI_UNFOLD_PHI1]], [[SEL_2_SI_UNFOLD_FALSE]] ] ; CHECK-NEXT: br label [[FOR_INC]] -; CHECK: sel.3.si.unfold.false.jt4: -; CHECK-NEXT: [[SEL_2_SI_UNFOLD_PHI_JT4:%.*]] = phi i32 [ [[DOTSI_UNFOLD_PHI1_JT4]], [[SEL_2_SI_UNFOLD_FALSE_JT4]] ] -; CHECK-NEXT: br label [[FOR_INC_JT4]] ; CHECK: sel.3.si.unfold.false.jt3: -; CHECK-NEXT: [[SEL_2_SI_UNFOLD_PHI_JT3:%.*]] = phi i32 [ [[DOTSI_UNFOLD_PHI_JT3]], [[SEL_2_SI_UNFOLD_TRUE_JT3]] ] +; CHECK-NEXT: [[SEL_2_SI_UNFOLD_PHI_JT3:%.*]] = phi i32 [ [[DOTSI_UNFOLD_PHI_JT3]], [[SEL_2_SI_UNFOLD_TRUE_JT3]] ], [ [[DOTSI_UNFOLD_PHI1_JT4]], [[SEL_2_SI_UNFOLD_FALSE_JT4]] ] ; CHECK-NEXT: br label [[FOR_INC_JT3]] ; CHECK: sel.1.si.unfold.true: ; CHECK-NEXT: br i1 [[CMP_1]], label [[FOR_INC]], label [[SEL_1_SI_UNFOLD_FALSE_JT2:%.*]] @@ -289,11 +282,6 @@ define i32 @test3(i32 %num) { ; CHECK-NEXT: [[INC]] = add nsw i32 [[COUNT5]], 1 ; CHECK-NEXT: [[CMP_EXIT:%.*]] = icmp slt i32 [[INC]], [[NUM:%.*]] ; CHECK-NEXT: br i1 [[CMP_EXIT]], label [[FOR_BODY]], label [[FOR_END:%.*]] -; CHECK: for.inc.jt4: -; CHECK-NEXT: [[STATE_NEXT_JT4]] = phi i32 [ [[SEL_2_SI_UNFOLD_PHI_JT4]], [[SEL_3_SI_UNFOLD_FALSE_JT4]] ] -; CHECK-NEXT: [[INC_JT4]] = add nsw i32 undef, 1 -; CHECK-NEXT: [[CMP_EXIT_JT4:%.*]] = icmp slt i32 [[INC_JT4]], [[NUM]] -; CHECK-NEXT: br i1 [[CMP_EXIT_JT4]], label [[FOR_BODY_JT4:%.*]], label [[FOR_END]] ; CHECK: for.inc.jt3: ; CHECK-NEXT: [[STATE_NEXT_JT3]] = phi i32 [ [[SEL_2_SI_UNFOLD_PHI_JT3]], [[SEL_3_SI_UNFOLD_FALSE_JT3]] ] ; CHECK-NEXT: [[INC_JT3]] = add nsw i32 [[COUNT5]], 1 @@ -305,8 +293,8 @@ define i32 @test3(i32 %num) { ; CHECK-NEXT: [[CMP_EXIT_JT2:%.*]] = icmp slt i32 [[INC_JT2]], [[NUM]] ; CHECK-NEXT: br i1 [[CMP_EXIT_JT2]], label [[FOR_BODY_JT2]], label [[FOR_END]] ; CHECK: for.inc.jt1: -; CHECK-NEXT: [[COUNT4:%.*]] = phi i32 [ [[COUNT_JT4]], [[FOR_BODY_JT4]] ], [ [[COUNT_JT3]], [[FOR_BODY_JT3]] ], [ [[COUNT5]], [[SEL_1_SI_UNFOLD_TRUE_JT1]] ], [ [[COUNT]], [[FOR_BODY]] ] -; CHECK-NEXT: [[STATE_NEXT_JT1]] = phi i32 [ 1, [[FOR_BODY]] ], [ 1, [[FOR_BODY_JT3]] ], [ 1, [[FOR_BODY_JT4]] ], [ [[DOTSI_UNFOLD_PHI2_JT1]], [[SEL_1_SI_UNFOLD_TRUE_JT1]] ] +; CHECK-NEXT: [[COUNT4:%.*]] = phi i32 [ [[COUNT_JT3]], [[FOR_BODY_JT3]] ], [ [[COUNT5]], [[SEL_1_SI_UNFOLD_TRUE_JT1]] ], [ [[COUNT]], [[FOR_BODY]] ] +; CHECK-NEXT: [[STATE_NEXT_JT1]] = phi i32 [ 1, [[FOR_BODY]] ], [ 1, [[FOR_BODY_JT3]] ], [ [[DOTSI_UNFOLD_PHI2_JT1]], [[SEL_1_SI_UNFOLD_TRUE_JT1]] ] ; CHECK-NEXT: [[INC_JT1]] = add nsw i32 [[COUNT4]], 1 ; CHECK-NEXT: [[CMP_EXIT_JT1:%.*]] = icmp slt i32 [[INC_JT1]], [[NUM]] ; CHECK-NEXT: br i1 [[CMP_EXIT_JT1]], label [[FOR_BODY_JT1]], label [[FOR_END]] @@ -402,36 +390,28 @@ define void @pr65222(i32 %flags, i1 %cmp, i1 %tobool.not) { ; CHECK-NEXT: br label [[IF_END_JT2:%.*]] ; CHECK: cond1.si.unfold.true: ; CHECK-NEXT: br i1 [[CMP]], label [[IF_END]], label [[COND1_SI_UNFOLD_FALSE_JT1:%.*]] -; CHECK: cond1.si.unfold.true.jt3: +; CHECK: cond1.si.unfold.true.jt2: ; CHECK-NEXT: [[DOTSI_UNFOLD_PHI2:%.*]] = phi i32 [ 3, [[THEN]] ] -; CHECK-NEXT: br i1 [[CMP]], label [[IF_END_JT3:%.*]], label [[COND1_SI_UNFOLD_FALSE:%.*]] +; CHECK-NEXT: br i1 [[CMP]], label [[IF_END_JT2]], label [[COND1_SI_UNFOLD_FALSE:%.*]] ; CHECK: cond1.si.unfold.false: ; CHECK-NEXT: [[DOTSI_UNFOLD_PHI3:%.*]] = phi i32 [ 1, [[COND1_SI_UNFOLD_TRUE]] ] ; CHECK-NEXT: br label [[IF_END]] -; CHECK: cond1.si.unfold.false.jt1: +; CHECK: cond1.si.unfold.false.jt2: ; CHECK-NEXT: [[DOTSI_UNFOLD_PHI3_JT1:%.*]] = phi i32 [ 1, [[COND1_SI_UNFOLD_TRUE1:%.*]] ] -; CHECK-NEXT: br label [[IF_END_JT1:%.*]] +; CHECK-NEXT: br label [[IF_END_JT2]] ; CHECK: if.end: ; CHECK-NEXT: [[UNFOLDED:%.*]] = phi i32 [ [[FLAGS:%.*]], [[WHILE_COND]] ], [ [[COND_SI_UNFOLD_PHI]], [[TOUNFOLD_SI_UNFOLD_FALSE1]] ], [ poison, [[COND1_SI_UNFOLD_TRUE1]] ], [ [[DOTSI_UNFOLD_PHI3]], [[COND1_SI_UNFOLD_FALSE]] ] ; CHECK-NEXT: [[OTHER:%.*]] = phi i32 [ [[FLAGS]], [[WHILE_COND]] ], [ 0, [[TOUNFOLD_SI_UNFOLD_FALSE1]] ], [ 0, [[COND1_SI_UNFOLD_TRUE1]] ], [ 0, [[COND1_SI_UNFOLD_FALSE]] ] ; CHECK-NEXT: switch i32 [[UNFOLDED]], label [[UNREACHABLE:%.*]] [ ; CHECK-NEXT: i32 0, label [[SW_BB:%.*]] ; CHECK-NEXT: ] -; CHECK: if.end.jt1: -; CHECK-NEXT: [[UNFOLDED_JT1:%.*]] = phi i32 [ [[DOTSI_UNFOLD_PHI3_JT1]], [[COND1_SI_UNFOLD_FALSE_JT1]] ] -; CHECK-NEXT: [[OTHER_JT1:%.*]] = phi i32 [ 0, [[COND1_SI_UNFOLD_FALSE_JT1]] ] -; CHECK-NEXT: br label [[UNREACHABLE]] -; CHECK: if.end.jt3: -; CHECK-NEXT: [[UNFOLDED_JT3:%.*]] = phi i32 [ [[DOTSI_UNFOLD_PHI2]], [[COND1_SI_UNFOLD_TRUE]] ] -; CHECK-NEXT: [[OTHER_JT3:%.*]] = phi i32 [ 0, [[COND1_SI_UNFOLD_TRUE]] ] -; CHECK-NEXT: br label [[UNREACHABLE]] ; CHECK: if.end.jt0: ; CHECK-NEXT: [[UNFOLDED_JT0:%.*]] = phi i32 [ [[COND_SI_UNFOLD_PHI_JT0]], [[TOUNFOLD_SI_UNFOLD_FALSE_JT0]] ] ; CHECK-NEXT: [[OTHER_JT0:%.*]] = phi i32 [ 0, [[TOUNFOLD_SI_UNFOLD_FALSE_JT0]] ] ; CHECK-NEXT: br label [[SW_BB]] ; CHECK: if.end.jt2: -; CHECK-NEXT: [[UNFOLDED_JT2:%.*]] = phi i32 [ [[COND_SI_UNFOLD_PHI_JT2]], [[TOUNFOLD_SI_UNFOLD_FALSE]] ] -; CHECK-NEXT: [[OTHER_JT2:%.*]] = phi i32 [ 0, [[TOUNFOLD_SI_UNFOLD_FALSE]] ] +; CHECK-NEXT: [[UNFOLDED_JT2:%.*]] = phi i32 [ [[COND_SI_UNFOLD_PHI_JT2]], [[TOUNFOLD_SI_UNFOLD_FALSE]] ], [ [[DOTSI_UNFOLD_PHI2]], [[COND1_SI_UNFOLD_TRUE]] ], [ [[DOTSI_UNFOLD_PHI3_JT1]], [[COND1_SI_UNFOLD_FALSE_JT1]] ] +; CHECK-NEXT: [[OTHER_JT2:%.*]] = phi i32 [ 0, [[TOUNFOLD_SI_UNFOLD_FALSE]] ], [ 0, [[COND1_SI_UNFOLD_TRUE]] ], [ 0, [[COND1_SI_UNFOLD_FALSE_JT1]] ] ; CHECK-NEXT: br label [[UNREACHABLE]] ; CHECK: unreachable: ; CHECK-NEXT: unreachable diff --git a/llvm/test/Transforms/DFAJumpThreading/equivalent-states.ll b/llvm/test/Transforms/DFAJumpThreading/equivalent-states.ll new file mode 100644 index 0000000..4555dfb --- /dev/null +++ b/llvm/test/Transforms/DFAJumpThreading/equivalent-states.ll @@ -0,0 +1,281 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3 +; RUN: opt -S -passes=dfa-jump-threading %s | FileCheck %s + +declare void @do_something() +declare void @user(i32) + +define void @equivalent_on_default(i1 %c1) { +; CHECK-LABEL: define void @equivalent_on_default( +; CHECK-SAME: i1 [[C1:%.*]]) { +; CHECK-NEXT: entry: +; CHECK-NEXT: br label [[SWITCH_BB:%.*]] +; CHECK: switch_bb: +; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ] +; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [ +; CHECK-NEXT: i32 0, label [[CASE1:%.*]] +; CHECK-NEXT: i32 1, label [[CASE2:%.*]] +; CHECK-NEXT: ] +; CHECK: switch_bb.jt2: +; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ] +; CHECK-NEXT: br label [[DEFAULT_DEST]] +; CHECK: switch_bb.jt1: +; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ] +; CHECK-NEXT: br label [[CASE2]] +; CHECK: case1: +; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]] +; CHECK: case2: +; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]] +; CHECK: case2then: +; CHECK-NEXT: br label [[CASE2END_JT2]] +; CHECK: case2end: +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB]] +; CHECK: case2end.jt2: +; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ] +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]] +; CHECK: default_dest: +; CHECK-NEXT: ret void +; +entry: + br label %switch_bb + +switch_bb: + %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ] + switch i32 %phi, label %default_dest [ + i32 0, label %case1 + i32 1, label %case2 + ] + +case1: + br label %switch_bb + +case2: + br i1 %c1, label %case2then, label %case2end + +case2then: + br label %case2end + +case2end: + %phi_case2 = phi i32 [ 2, %case2 ] , [ 3, %case2then ] + call void @do_something() + br label %switch_bb + +default_dest: + ret void +} + +define void @equivalent_on_default_user(i1 %c1) { +; CHECK-LABEL: define void @equivalent_on_default_user( +; CHECK-SAME: i1 [[C1:%.*]]) { +; CHECK-NEXT: entry: +; CHECK-NEXT: br label [[SWITCH_BB:%.*]] +; CHECK: switch_bb: +; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ] +; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [ +; CHECK-NEXT: i32 0, label [[CASE1:%.*]] +; CHECK-NEXT: i32 1, label [[CASE2:%.*]] +; CHECK-NEXT: ] +; CHECK: switch_bb.jt2: +; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ] +; CHECK-NEXT: br label [[DEFAULT_DEST]] +; CHECK: switch_bb.jt1: +; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ] +; CHECK-NEXT: br label [[CASE2]] +; CHECK: case1: +; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]] +; CHECK: case2: +; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]] +; CHECK: case2then: +; CHECK-NEXT: br label [[CASE2END_JT2]] +; CHECK: case2end: +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: call void @user(i32 poison) +; CHECK-NEXT: br label [[SWITCH_BB]] +; CHECK: case2end.jt2: +; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ] +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: call void @user(i32 [[PHI_CASE2_JT2]]) +; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]] +; CHECK: default_dest: +; CHECK-NEXT: ret void +; +entry: + br label %switch_bb + +switch_bb: + %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ] + switch i32 %phi, label %default_dest [ + i32 0, label %case1 + i32 1, label %case2 + ] + +case1: + br label %switch_bb + +case2: + br i1 %c1, label %case2then, label %case2end + +case2then: + br label %case2end + +case2end: + %phi_case2 = phi i32 [ 2, %case2 ] , [ 3, %case2then ] + call void @do_something() + call void @user(i32 %phi_case2) + br label %switch_bb + +default_dest: + ret void +} + +define void @equivalent_only_cases(i1 %c1) { +; CHECK-LABEL: define void @equivalent_only_cases( +; CHECK-SAME: i1 [[C1:%.*]]) { +; CHECK-NEXT: entry: +; CHECK-NEXT: br label [[SWITCH_BB:%.*]] +; CHECK: switch_bb: +; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ] +; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [ +; CHECK-NEXT: i32 0, label [[CASE1:%.*]] +; CHECK-NEXT: i32 1, label [[CASE2:%.*]] +; CHECK-NEXT: i32 2, label [[CASE1]] +; CHECK-NEXT: i32 3, label [[CASE1]] +; CHECK-NEXT: ] +; CHECK: switch_bb.jt2: +; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ] +; CHECK-NEXT: br label [[CASE1]] +; CHECK: switch_bb.jt1: +; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ] +; CHECK-NEXT: br label [[CASE2]] +; CHECK: case1: +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]] +; CHECK: case2: +; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]] +; CHECK: case2then: +; CHECK-NEXT: br label [[CASE2END_JT2]] +; CHECK: case2end: +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB]] +; CHECK: case2end.jt2: +; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ] +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]] +; CHECK: default_dest: +; CHECK-NEXT: ret void +; +entry: + br label %switch_bb + +switch_bb: + %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ] + switch i32 %phi, label %default_dest [ + i32 0, label %case1 + i32 1, label %case2 + i32 2, label %case1 + i32 3, label %case1 + ] + +case1: + call void @do_something() + br label %switch_bb + +case2: + br i1 %c1, label %case2then, label %case2end + +case2then: + br label %case2end + +case2end: + %phi_case2 = phi i32 [ 2, %case2 ] , [ 3, %case2then ] + call void @do_something() + br label %switch_bb + +default_dest: + ret void +} + +define void @equivalent_both_case_and_default(i1 %c1, i1 %c2) { +; CHECK-LABEL: define void @equivalent_both_case_and_default( +; CHECK-SAME: i1 [[C1:%.*]], i1 [[C2:%.*]]) { +; CHECK-NEXT: entry: +; CHECK-NEXT: br label [[SWITCH_BB:%.*]] +; CHECK: switch_bb: +; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ poison, [[CASE2END:%.*]] ] +; CHECK-NEXT: switch i32 [[PHI]], label [[DEFAULT_DEST:%.*]] [ +; CHECK-NEXT: i32 0, label [[CASE1:%.*]] +; CHECK-NEXT: i32 1, label [[CASE2:%.*]] +; CHECK-NEXT: i32 2, label [[CASE1]] +; CHECK-NEXT: i32 3, label [[CASE1]] +; CHECK-NEXT: ] +; CHECK: switch_bb.jt4: +; CHECK-NEXT: [[PHI_JT3:%.*]] = phi i32 [ [[PHI_CASE2_JT3:%.*]], [[CASE2END_JT3:%.*]] ] +; CHECK-NEXT: br label [[DEFAULT_DEST]] +; CHECK: switch_bb.jt2: +; CHECK-NEXT: [[PHI_JT2:%.*]] = phi i32 [ [[PHI_CASE2_JT2:%.*]], [[CASE2END_JT2:%.*]] ] +; CHECK-NEXT: br label [[CASE1]] +; CHECK: switch_bb.jt1: +; CHECK-NEXT: [[PHI_JT1:%.*]] = phi i32 [ 1, [[CASE1]] ] +; CHECK-NEXT: br label [[CASE2]] +; CHECK: case1: +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB_JT1:%.*]] +; CHECK: case2: +; CHECK-NEXT: br i1 [[C1]], label [[CASE2THEN:%.*]], label [[CASE2END_JT2]] +; CHECK: case2then: +; CHECK-NEXT: br i1 [[C2]], label [[CASE2THEN2:%.*]], label [[CASE2END_JT2]] +; CHECK: case2then2: +; CHECK-NEXT: br i1 [[C2]], label [[CASE2THEN3:%.*]], label [[CASE2END_JT3]] +; CHECK: case2then3: +; CHECK-NEXT: br label [[CASE2END_JT3]] +; CHECK: case2end: +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB]] +; CHECK: case2end.jt4: +; CHECK-NEXT: [[PHI_CASE2_JT3]] = phi i32 [ 4, [[CASE2THEN2]] ], [ 5, [[CASE2THEN3]] ] +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB_JT3:%.*]] +; CHECK: case2end.jt2: +; CHECK-NEXT: [[PHI_CASE2_JT2]] = phi i32 [ 2, [[CASE2]] ], [ 3, [[CASE2THEN]] ] +; CHECK-NEXT: call void @do_something() +; CHECK-NEXT: br label [[SWITCH_BB_JT2:%.*]] +; CHECK: default_dest: +; CHECK-NEXT: ret void +; +entry: + br label %switch_bb + +switch_bb: + %phi = phi i32 [ 0, %entry ], [ 1, %case1 ], [ %phi_case2, %case2end ] + switch i32 %phi, label %default_dest [ + i32 0, label %case1 + i32 1, label %case2 + i32 2, label %case1 + i32 3, label %case1 + ] + +case1: + call void @do_something() + br label %switch_bb + +case2: + br i1 %c1, label %case2then, label %case2end + +case2then: + br i1 %c2, label %case2then2, label %case2end + +case2then2: + br i1 %c2, label %case2then3, label %case2end + +case2then3: + br label %case2end + +case2end: + %phi_case2 = phi i32 [ 2, %case2 ], [ 3, %case2then ], [ 4, %case2then2 ], [ 5, %case2then3 ] + call void @do_something() + br label %switch_bb + +default_dest: + ret void +} diff --git a/llvm/test/Transforms/GVN/condprop.ll b/llvm/test/Transforms/GVN/condprop.ll index eb2a9f1..57bd2f3 100644 --- a/llvm/test/Transforms/GVN/condprop.ll +++ b/llvm/test/Transforms/GVN/condprop.ll @@ -360,7 +360,7 @@ define i1 @test6_phi2(i1 %c, i32 %x, i32 %y) { ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X]], [[Y]] ; CHECK-NEXT: br i1 [[CMP]], label [[BB2]], label [[BB3:%.*]] ; CHECK: bb2: -; CHECK-NEXT: [[PHI:%.*]] = phi i1 [ [[CMP_NOT]], [[BB1]] ], [ true, [[ENTRY:%.*]] ] +; CHECK-NEXT: [[PHI:%.*]] = phi i1 [ false, [[BB1]] ], [ true, [[ENTRY:%.*]] ] ; CHECK-NEXT: ret i1 [[PHI]] ; CHECK: bb3: ; CHECK-NEXT: ret i1 false diff --git a/llvm/test/Transforms/InstCombine/ptrtoaddr.ll b/llvm/test/Transforms/InstCombine/ptrtoaddr.ll index 5211fbd..7b0b152 100644 --- a/llvm/test/Transforms/InstCombine/ptrtoaddr.ll +++ b/llvm/test/Transforms/InstCombine/ptrtoaddr.ll @@ -10,8 +10,18 @@ target datalayout = "pe1:64:64:64:32" @g.as1 = external addrspace(1) global i8 @g2.as1 = external addrspace(1) global i8 -define i32 @ptrtoaddr_inttoptr_arg(i32 %a) { -; CHECK-LABEL: define i32 @ptrtoaddr_inttoptr_arg( +define i64 @ptrtoaddr_inttoptr_arg(i64 %a) { +; CHECK-LABEL: define i64 @ptrtoaddr_inttoptr_arg( +; CHECK-SAME: i64 [[A:%.*]]) { +; CHECK-NEXT: ret i64 [[A]] +; + %toptr = inttoptr i64 %a to ptr + %toaddr = ptrtoaddr ptr %toptr to i64 + ret i64 %toaddr +} + +define i32 @ptrtoaddr_inttoptr_arg_addrsize(i32 %a) { +; CHECK-LABEL: define i32 @ptrtoaddr_inttoptr_arg_addrsize( ; CHECK-SAME: i32 [[A:%.*]]) { ; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[A]] to i64 ; CHECK-NEXT: [[TOPTR:%.*]] = inttoptr i64 [[TMP1]] to ptr addrspace(1) @@ -130,3 +140,27 @@ define i32 @ptrtoaddr_sub_consts_offset_addrsize() { ; ret i32 sub (i32 ptrtoaddr (ptr addrspace(1) getelementptr (i8, ptr addrspace(1) @g.as1, i32 42) to i32), i32 ptrtoaddr (ptr addrspace(1) @g.as1 to i32)) } + +define i64 @ptrtoaddr_sub_known_offset(ptr %p) { +; CHECK-LABEL: define i64 @ptrtoaddr_sub_known_offset( +; CHECK-SAME: ptr [[P:%.*]]) { +; CHECK-NEXT: ret i64 42 +; + %p2 = getelementptr inbounds i8, ptr %p, i64 42 + %p.addr = ptrtoaddr ptr %p to i64 + %p2.addr = ptrtoaddr ptr %p2 to i64 + %sub = sub i64 %p2.addr, %p.addr + ret i64 %sub +} + +define i32 @ptrtoaddr_sub_known_offset_addrsize(ptr addrspace(1) %p) { +; CHECK-LABEL: define i32 @ptrtoaddr_sub_known_offset_addrsize( +; CHECK-SAME: ptr addrspace(1) [[P:%.*]]) { +; CHECK-NEXT: ret i32 42 +; + %p2 = getelementptr inbounds i8, ptr addrspace(1) %p, i32 42 + %p.addr = ptrtoaddr ptr addrspace(1) %p to i32 + %p2.addr = ptrtoaddr ptr addrspace(1) %p2 to i32 + %sub = sub i32 %p2.addr, %p.addr + ret i32 %sub +} diff --git a/llvm/test/Transforms/InstCombine/select-safe-transforms.ll b/llvm/test/Transforms/InstCombine/select-safe-transforms.ll index ebea5bf..d88eaf8 100644 --- a/llvm/test/Transforms/InstCombine/select-safe-transforms.ll +++ b/llvm/test/Transforms/InstCombine/select-safe-transforms.ll @@ -1,8 +1,11 @@ -; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals ; RUN: opt < %s -passes=instcombine -S | FileCheck %s declare i1 @gen1() +;. +; CHECK: @glb = global i8 0 +;. define i1 @cond_eq_and(i8 %X, i8 %Y, i8 noundef %C) { ; CHECK-LABEL: @cond_eq_and( ; CHECK-NEXT: [[COND:%.*]] = icmp eq i8 [[X:%.*]], [[C:%.*]] @@ -16,16 +19,16 @@ define i1 @cond_eq_and(i8 %X, i8 %Y, i8 noundef %C) { ret i1 %res } -define i1 @cond_eq_and_const(i8 %X, i8 %Y) { +define i1 @cond_eq_and_const(i8 %X, i8 %Y) !prof !0 { ; CHECK-LABEL: @cond_eq_and_const( ; CHECK-NEXT: [[COND:%.*]] = icmp eq i8 [[X:%.*]], 10 ; CHECK-NEXT: [[TMP1:%.*]] = icmp ugt i8 [[Y:%.*]], 10 -; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND]], i1 [[TMP1]], i1 false +; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND]], i1 [[TMP1]], i1 false, !prof [[PROF1:![0-9]+]] ; CHECK-NEXT: ret i1 [[RES]] ; %cond = icmp eq i8 %X, 10 %lhs = icmp ult i8 %X, %Y - %res = select i1 %cond, i1 %lhs, i1 false + %res = select i1 %cond, i1 %lhs, i1 false, !prof !1 ret i1 %res } @@ -42,16 +45,16 @@ define i1 @cond_eq_or(i8 %X, i8 %Y, i8 noundef %C) { ret i1 %res } -define i1 @cond_eq_or_const(i8 %X, i8 %Y) { +define i1 @cond_eq_or_const(i8 %X, i8 %Y) !prof !0 { ; CHECK-LABEL: @cond_eq_or_const( ; CHECK-NEXT: [[COND:%.*]] = icmp ne i8 [[X:%.*]], 10 ; CHECK-NEXT: [[TMP1:%.*]] = icmp ugt i8 [[Y:%.*]], 10 -; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND]], i1 true, i1 [[TMP1]] +; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND]], i1 true, i1 [[TMP1]], !prof [[PROF1]] ; CHECK-NEXT: ret i1 [[RES]] ; %cond = icmp ne i8 %X, 10 %lhs = icmp ult i8 %X, %Y - %res = select i1 %cond, i1 true, i1 %lhs + %res = select i1 %cond, i1 true, i1 %lhs, !prof !1 ret i1 %res } @@ -793,3 +796,10 @@ define <2 x i1> @not_logical_and2(i1 %b, <2 x i32> %a) { %or = select <2 x i1> %and, <2 x i1> <i1 true, i1 true>, <2 x i1> %implied ret <2 x i1> %or } + +!0 = !{!"function_entry_count", i64 1000} +!1 = !{!"branch_weights", i32 2, i32 3} +;. +; CHECK: [[META0:![0-9]+]] = !{!"function_entry_count", i64 1000} +; CHECK: [[PROF1]] = !{!"branch_weights", i32 2, i32 3} +;. diff --git a/llvm/test/Transforms/InstCombine/sprintf-1.ll b/llvm/test/Transforms/InstCombine/sprintf-1.ll index 1d87758..1798514 100644 --- a/llvm/test/Transforms/InstCombine/sprintf-1.ll +++ b/llvm/test/Transforms/InstCombine/sprintf-1.ll @@ -5,8 +5,7 @@ ; RUN: opt < %s -mtriple xcore-xmos-elf -passes=instcombine -S | FileCheck %s -check-prefixes=CHECK,WITHSTPCPY,CHECK-IPRINTF ; RUN: opt < %s -mtriple=i386-pc-windows-msvc -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY ; RUN: opt < %s -mtriple=i386-mingw32 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY -; RUN: opt < %s -mtriple=armv7-none-linux-android16 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY -; RUN: opt < %s -mtriple=armv7-none-linux-android21 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,WITHSTPCPY +; RUN: opt < %s -mtriple=armv7-none-linux-android -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,WITHSTPCPY ; RUN: opt < %s -mtriple=x86_64-scei-ps4 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" diff --git a/llvm/test/Transforms/InstSimplify/ptr_diff.ll b/llvm/test/Transforms/InstSimplify/ptr_diff.ll index fdd9e8e..508dfbc 100644 --- a/llvm/test/Transforms/InstSimplify/ptr_diff.ll +++ b/llvm/test/Transforms/InstSimplify/ptr_diff.ll @@ -14,11 +14,7 @@ define i64 @ptrdiff(ptr %ptr) { define i64 @ptrdiff_no_inbounds(ptr %ptr) { ; CHECK-LABEL: @ptrdiff_no_inbounds( -; CHECK-NEXT: [[LAST:%.*]] = getelementptr i8, ptr [[PTR:%.*]], i32 42 -; CHECK-NEXT: [[FIRST_INT:%.*]] = ptrtoint ptr [[PTR]] to i64 -; CHECK-NEXT: [[LAST_INT:%.*]] = ptrtoint ptr [[LAST]] to i64 -; CHECK-NEXT: [[DIFF:%.*]] = sub i64 [[LAST_INT]], [[FIRST_INT]] -; CHECK-NEXT: ret i64 [[DIFF]] +; CHECK-NEXT: ret i64 42 ; %last = getelementptr i8, ptr %ptr, i32 42 %first.int = ptrtoint ptr %ptr to i64 diff --git a/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll b/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll index e66127533..3b6fb3a 100644 --- a/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll +++ b/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll @@ -1,9 +1,7 @@ ; RUN: opt -safe-stack -S -mtriple=i686-pc-linux-gnu < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefixes=COMMON,TLS64 %s -; RUN: opt -safe-stack -S -mtriple=i686-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,GLOBAL32 %s -; RUN: opt -safe-stack -S -mtriple=i686-linux-android24 < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s - +; RUN: opt -safe-stack -S -mtriple=i686-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s ; RUN: opt -safe-stack -S -mtriple=x86_64-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,TLS64 %s ; RUN: opt -safe-stack -S -mtriple=x86_64-unknown-fuchsia < %s -o - | FileCheck --check-prefixes=COMMON,FUCHSIA64 %s @@ -11,9 +9,7 @@ ; RUN: opt -passes=safe-stack -S -mtriple=i686-pc-linux-gnu < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s ; RUN: opt -passes=safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefixes=COMMON,TLS64 %s -; RUN: opt -passes=safe-stack -S -mtriple=i686-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,GLOBAL32 %s -; RUN: opt -passes=safe-stack -S -mtriple=i686-linux-android24 < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s - +; RUN: opt -passes=safe-stack -S -mtriple=i686-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s ; RUN: opt -passes=safe-stack -S -mtriple=x86_64-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,TLS64 %s ; RUN: opt -passes=safe-stack -S -mtriple=x86_64-unknown-fuchsia < %s -o - | FileCheck --check-prefixes=COMMON,FUCHSIA64 %s diff --git a/llvm/test/tools/llvm-dwarfdump/X86/DW_AT_language_name.s b/llvm/test/tools/llvm-dwarfdump/X86/DW_AT_language_name.s new file mode 100644 index 0000000..af58175 --- /dev/null +++ b/llvm/test/tools/llvm-dwarfdump/X86/DW_AT_language_name.s @@ -0,0 +1,35 @@ +# Demonstrate dumping DW_AT_language_name. +# RUN: llvm-mc -triple=x86_64--linux -filetype=obj < %s | \ +# RUN: llvm-dwarfdump -v - | FileCheck %s + +# CHECK: .debug_abbrev contents: +# CHECK: DW_AT_language_name DW_FORM_data2 +# CHECK: DW_AT_language_name DW_FORM_data2 +# CHECK: .debug_info contents: +# CHECK: DW_AT_language_name [DW_FORM_data2] (DW_LNAME_C) +# CHECK: DW_AT_language_name [DW_FORM_data2] (0x0000) + + .section .debug_abbrev,"",@progbits + .byte 1 # Abbreviation Code + .byte 17 # DW_TAG_compile_unit + .byte 1 # DW_CHILDREN_no + .ascii "\220\001" # DW_AT_language_name + .byte 5 # DW_FORM_data2 + .ascii "\220\001" # DW_AT_language_name + .byte 5 # DW_FORM_data2 + .byte 0 # EOM(1) + .byte 0 # EOM(2) + .byte 0 # EOM(3) + + .section .debug_info,"",@progbits + .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit +.Ldebug_info_start0: + .short 5 # DWARF version number + .byte 1 # Unit type + .byte 8 # Address Size (in bytes) + .long .debug_abbrev # Offset Into Abbrev. Section + .byte 1 # Abbrev [1] DW_TAG_compile_unit + .short 3 # DW_AT_language_name + .short 0 # DW_AT_language_name + .byte 0 +.Ldebug_info_end0: diff --git a/llvm/test/tools/llvm-dwarfdump/X86/DW_AT_language_version.s b/llvm/test/tools/llvm-dwarfdump/X86/DW_AT_language_version.s new file mode 100644 index 0000000..f1be8fd --- /dev/null +++ b/llvm/test/tools/llvm-dwarfdump/X86/DW_AT_language_version.s @@ -0,0 +1,35 @@ +# Demonstrate dumping DW_AT_language_version. +# RUN: llvm-mc -triple=x86_64--linux -filetype=obj < %s | \ +# RUN: llvm-dwarfdump -v - | FileCheck %s + +# CHECK: .debug_abbrev contents: +# CHECK: DW_AT_language_version DW_FORM_data4 +# CHECK: DW_AT_language_version DW_FORM_data2 +# CHECK: .debug_info contents: +# CHECK: DW_AT_language_version [DW_FORM_data4] (201402) +# CHECK: DW_AT_language_version [DW_FORM_data2] (0) + + .section .debug_abbrev,"",@progbits + .byte 1 # Abbreviation Code + .byte 17 # DW_TAG_compile_unit + .byte 1 # DW_CHILDREN_no + .ascii "\221\001" # DW_AT_language_version + .byte 6 # DW_FORM_data4 + .ascii "\221\001" # DW_AT_language_version + .byte 5 # DW_FORM_data2 + .byte 0 # EOM(1) + .byte 0 # EOM(2) + .byte 0 # EOM(3) + + .section .debug_info,"",@progbits + .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit +.Ldebug_info_start0: + .short 5 # DWARF version number + .byte 1 # Unit type + .byte 8 # Address Size (in bytes) + .long .debug_abbrev # Offset Into Abbrev. Section + .byte 1 # Abbrev [1] DW_TAG_compile_unit + .long 201402 # DW_AT_language_version + .short 0 # DW_AT_language_version + .byte 0 +.Ldebug_info_end0: diff --git a/llvm/unittests/ADT/BitsetTest.cpp b/llvm/unittests/ADT/BitsetTest.cpp new file mode 100644 index 0000000..0ecd213 --- /dev/null +++ b/llvm/unittests/ADT/BitsetTest.cpp @@ -0,0 +1,71 @@ +//===- llvm/unittest/Support/BitsetTest.cpp -------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/Bitset.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +template <unsigned NumBits> +class TestBitsetUInt64Array : public Bitset<NumBits> { + static constexpr unsigned NumElts = (NumBits + 63) / 64; + +public: + TestBitsetUInt64Array(const std::array<uint64_t, NumElts> &B) + : Bitset<NumBits>(B) {} + + bool verifyValue(const std::array<uint64_t, NumElts> &B) const { + for (unsigned I = 0; I != NumBits; ++I) { + bool ReferenceVal = + (B[(I / 64)] & (static_cast<uint64_t>(1) << (I % 64))) != 0; + if (ReferenceVal != this->test(I)) + return false; + } + + return true; + } + + void verifyStorageSize(size_t elements_64_bit, size_t elements_32_bit) { + if constexpr (sizeof(uintptr_t) == sizeof(uint64_t)) + EXPECT_EQ(sizeof(*this), elements_64_bit * sizeof(uintptr_t)); + else + EXPECT_EQ(sizeof(*this), elements_32_bit * sizeof(uintptr_t)); + } +}; + +TEST(BitsetTest, Construction) { + std::array<uint64_t, 2> TestVals = {0x123456789abcdef3, 0x1337d3a0b22c24}; + TestBitsetUInt64Array<96> Test(TestVals); + EXPECT_TRUE(Test.verifyValue(TestVals)); + Test.verifyStorageSize(2, 3); + + TestBitsetUInt64Array<65> Test1(TestVals); + EXPECT_TRUE(Test1.verifyValue(TestVals)); + Test1.verifyStorageSize(2, 3); + + std::array<uint64_t, 1> TestSingleVal = {0x12345678abcdef99}; + + TestBitsetUInt64Array<64> Test64(TestSingleVal); + EXPECT_TRUE(Test64.verifyValue(TestSingleVal)); + Test64.verifyStorageSize(1, 2); + + TestBitsetUInt64Array<30> Test30(TestSingleVal); + EXPECT_TRUE(Test30.verifyValue(TestSingleVal)); + Test30.verifyStorageSize(1, 1); + + TestBitsetUInt64Array<32> Test32(TestSingleVal); + EXPECT_TRUE(Test32.verifyValue(TestSingleVal)); + Test32.verifyStorageSize(1, 1); + + TestBitsetUInt64Array<33> Test33(TestSingleVal); + EXPECT_TRUE(Test33.verifyValue(TestSingleVal)); + Test33.verifyStorageSize(1, 2); +} +} // namespace diff --git a/llvm/unittests/ADT/CMakeLists.txt b/llvm/unittests/ADT/CMakeLists.txt index dafd735..848ccba 100644 --- a/llvm/unittests/ADT/CMakeLists.txt +++ b/llvm/unittests/ADT/CMakeLists.txt @@ -12,6 +12,7 @@ add_llvm_unittest(ADTTests BitFieldsTest.cpp BitmaskEnumTest.cpp BitTest.cpp + BitsetTest.cpp BitVectorTest.cpp BreadthFirstIteratorTest.cpp BumpPtrListTest.cpp diff --git a/llvm/unittests/IR/ConstantFPRangeTest.cpp b/llvm/unittests/IR/ConstantFPRangeTest.cpp index 255f62d..1436f0f 100644 --- a/llvm/unittests/IR/ConstantFPRangeTest.cpp +++ b/llvm/unittests/IR/ConstantFPRangeTest.cpp @@ -767,4 +767,39 @@ TEST_F(ConstantFPRangeTest, makeExactFCmpRegion) { } } +TEST_F(ConstantFPRangeTest, abs) { + EXPECT_EQ(Full.abs(), + ConstantFPRange(APFloat::getZero(Sem, /*Negative=*/false), + APFloat::getInf(Sem, /*Negative=*/false), + /*MayBeQNaN=*/true, + /*MayBeSNaN=*/true)); + EXPECT_EQ(Empty.abs(), Empty); + EXPECT_EQ(Zero.abs(), PosZero); + EXPECT_EQ(PosInf.abs(), PosInf); + EXPECT_EQ(NegInf.abs(), PosInf); + EXPECT_EQ(Some.abs(), SomePos); + EXPECT_EQ(SomeNeg.abs(), SomePos); + EXPECT_EQ(NaN.abs(), NaN); + EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(3.0)).abs(), + ConstantFPRange::getNonNaN(APFloat(0.0), APFloat(3.0))); + EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(2.0)).abs(), + ConstantFPRange::getNonNaN(APFloat(0.0), APFloat(3.0))); +} + +TEST_F(ConstantFPRangeTest, negate) { + EXPECT_EQ(Full.negate(), Full); + EXPECT_EQ(Empty.negate(), Empty); + EXPECT_EQ(Zero.negate(), Zero); + EXPECT_EQ(PosInf.negate(), NegInf); + EXPECT_EQ(NegInf.negate(), PosInf); + EXPECT_EQ(Some.negate(), Some); + EXPECT_EQ(SomePos.negate(), SomeNeg); + EXPECT_EQ(SomeNeg.negate(), SomePos); + EXPECT_EQ(NaN.negate(), NaN); + EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(3.0)).negate(), + ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(2.0))); + EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(2.0)).negate(), + ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(3.0))); +} + } // anonymous namespace diff --git a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp index 10f0213..fd8ddb1 100644 --- a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp +++ b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp @@ -588,7 +588,12 @@ void RuntimeLibcallEmitter::emitSystemRuntimeLibrarySetCalls( PredicateSorter.insert( PredicateWithCC()); // No predicate or CC override first. + constexpr unsigned BitsPerStorageElt = 64; DenseMap<PredicateWithCC, LibcallsWithCC> Pred2Funcs; + + SmallVector<uint64_t, 32> BitsetValues( + divideCeil(RuntimeLibcallImplDefList.size(), BitsPerStorageElt)); + for (const Record *Elt : *Elements) { const RuntimeLibcallImpl *LibCallImpl = getRuntimeLibcallImpl(Elt); if (!LibCallImpl) { @@ -597,16 +602,24 @@ void RuntimeLibcallEmitter::emitSystemRuntimeLibrarySetCalls( continue; } + size_t BitIdx = LibCallImpl->getEnumVal(); + uint64_t BitmaskVal = uint64_t(1) << (BitIdx % BitsPerStorageElt); + size_t BitsetIdx = BitIdx / BitsPerStorageElt; + auto It = Func2Preds.find(LibCallImpl); if (It == Func2Preds.end()) { + BitsetValues[BitsetIdx] |= BitmaskVal; Pred2Funcs[PredicateWithCC()].LibcallImpls.push_back(LibCallImpl); continue; } for (const Record *Pred : It->second.first) { const Record *CC = It->second.second; - PredicateWithCC Key(Pred, CC); + AvailabilityPredicate SubsetPredicate(Pred); + if (SubsetPredicate.isAlwaysAvailable()) + BitsetValues[BitsetIdx] |= BitmaskVal; + PredicateWithCC Key(Pred, CC); auto &Entry = Pred2Funcs[Key]; Entry.LibcallImpls.push_back(LibCallImpl); Entry.CallingConv = It->second.second; @@ -614,6 +627,22 @@ void RuntimeLibcallEmitter::emitSystemRuntimeLibrarySetCalls( } } + OS << " static constexpr LibcallImplBitset SystemAvailableImpls({\n" + << indent(6); + + ListSeparator LS; + unsigned EntryCount = 0; + for (uint64_t Bits : BitsetValues) { + if (EntryCount++ == 4) { + EntryCount = 1; + OS << ",\n" << indent(6); + } else + OS << LS; + OS << format_hex(Bits, 16); + } + OS << "\n });\n" + " AvailableLibcallImpls = SystemAvailableImpls;\n\n"; + SmallVector<PredicateWithCC, 0> SortedPredicates = PredicateSorter.takeVector(); diff --git a/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn index 5f9eb9a..eb8aef2 100644 --- a/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn @@ -27,8 +27,6 @@ static_library("Analysis") { "FixitUtil.cpp", "IntervalPartition.cpp", "IssueHash.cpp", - "LifetimeAnnotations.cpp", - "LifetimeSafety.cpp", "LiveVariables.cpp", "MacroExpansionContext.cpp", "ObjCNoReturn.cpp", diff --git a/llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn new file mode 100644 index 0000000..a148e78 --- /dev/null +++ b/llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn @@ -0,0 +1,16 @@ +static_library("LifetimeSafety") { + output_name = "clangAnalysisLifetimeSafety" + configs += [ "//llvm/utils/gn/build:clang_code" ] + deps = [ "//clang/lib/Basic" ] + sources = [ + "Checker.cpp", + "Facts.cpp", + "FactsGenerator.cpp", + "LifetimeAnnotations.cpp", + "LifetimeSafety.cpp", + "LiveOrigins.cpp", + "Loans.cpp", + "LoanPropagation.cpp", + "Origins.cpp", + ] +} diff --git a/llvm/utils/gn/secondary/clang/lib/Sema/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/Sema/BUILD.gn index 96ff481..14f44c4 100644 --- a/llvm/utils/gn/secondary/clang/lib/Sema/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/lib/Sema/BUILD.gn @@ -29,6 +29,7 @@ static_library("Sema") { "//clang/lib/APINotes", "//clang/lib/AST", "//clang/lib/Analysis", + "//clang/lib/Analysis/LifetimeSafety", "//clang/lib/Basic", "//clang/lib/Edit", "//clang/lib/Lex", diff --git a/llvm/utils/gn/secondary/llvm/unittests/ADT/BUILD.gn b/llvm/utils/gn/secondary/llvm/unittests/ADT/BUILD.gn index 92e596e..8d19d30 100644 --- a/llvm/utils/gn/secondary/llvm/unittests/ADT/BUILD.gn +++ b/llvm/utils/gn/secondary/llvm/unittests/ADT/BUILD.gn @@ -21,6 +21,7 @@ unittest("ADTTests") { "BitTest.cpp", "BitVectorTest.cpp", "BitmaskEnumTest.cpp", + "BitsetTest.cpp", "BreadthFirstIteratorTest.cpp", "BumpPtrListTest.cpp", "CoalescingBitVectorTest.cpp", diff --git a/mlir/include/mlir/Dialect/XeGPU/uArch/IntelGpuXe2.h b/mlir/include/mlir/Dialect/XeGPU/uArch/IntelGpuXe2.h new file mode 100644 index 0000000..0519f7b --- /dev/null +++ b/mlir/include/mlir/Dialect/XeGPU/uArch/IntelGpuXe2.h @@ -0,0 +1,297 @@ +//===--- IntelGpuXe2.h ------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// \file +// Xe2 uArch definition. Xe2 is the second generation of Intel Xe GPUs. +// This file defines the uArch details for Xe2 and its derived architectures. +// This includes Ponte Vecchio (PVC) and Battlemage (BMG) architectures. +// +//===----------------------------------------------------------------------===// +#ifndef MLIR_DIALECT_XEGPU_UARCH_INTELGPUXE2_H +#define MLIR_DIALECT_XEGPU_UARCH_INTELGPUXE2_H + +#include "mlir/Dialect/XeGPU/uArch/uArchBase.h" +#include "mlir/IR/BuiltinTypes.h" +#include "mlir/IR/TypeUtilities.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/DebugLog.h" +#include <map> +#include <string> + +#define DEBUG_TYPE "xegpu-uarch" + +using namespace mlir; +using namespace mlir::xegpu::uArch; + +namespace mlir { +namespace xegpu { +namespace uArch { + +struct Xe2Plus : public uArch { + XeCoreInfo xeCore; + Xe2Plus(const std::string &archName, const std::string &archDescription, + const XeCoreInfo &xeCore, + const std::map<RegisterFileType, RegisterFileInfo> ®Info = {}, + const llvm::SmallVector<CacheInfo, 4> &cacheInfo = {}, + const std::map<InstructionKind, std::shared_ptr<Instruction>> + &instrs = {}) + : uArch(archName, archDescription, regInfo, cacheInfo, instrs), + xeCore(xeCore) {} +}; + +// struct to represent DPAS instruction +struct DPASInstruction : public Instruction, public MMAInstructionInterface { + DPASInstruction() + : Instruction(InstructionKind::DPAS, InstructionScope::Subgroup) {} + + // Override all virtuals from MatrixOpInterface + virtual llvm::SmallVector<std::pair<uint32_t, uint32_t>, 16> + getSupportedShapes(Type dataType, MMAOpndKind matrixType) override; + virtual llvm::SmallVector<Type, 8> + getSupportedTypes(MLIRContext &context, MMAOpndKind matrixType) override; + virtual bool + checkSupportedShapesAndTypes(std::pair<uint32_t, uint32_t> AShape, + std::pair<uint32_t, uint32_t> BShape, + std::pair<uint32_t, uint32_t> CShape, + std::pair<uint32_t, uint32_t> DShape, Type AType, + Type BType, Type CType, Type DType) override; + virtual bool checkSupportedTypes(Type AType, Type BType, Type CType, + Type DType) override; + virtual bool validate(std::pair<uint32_t, uint32_t> AShape, + std::pair<uint32_t, uint32_t> BShape, + std::pair<uint32_t, uint32_t> CShape, + std::pair<uint32_t, uint32_t> DShape, Type AType, + Type BType, Type CType, Type DType) override; + virtual llvm::SmallVector<uint32_t, 8> getSupportedM(Type type) override; + virtual llvm::SmallVector<uint32_t, 8> getSupportedK(Type type) override; + virtual llvm::SmallVector<uint32_t, 8> getSupportedN(Type type) override; +}; + +struct PVCuArch : public Xe2Plus { + // Maintaines ownership of the instructions owned by PVUarch + llvm::SmallVector<std::shared_ptr<Instruction>, 8> owned_instructions; + PVCuArch() + : Xe2Plus("pvc", // archName + "Ponte Vecchio Architecture", // archDescription + XeCoreInfo(8, SharedMemory(512 * 1024, 4), 8, 8), // xeCore + {/* registerFileInfo */}, // Optional: empty + {/* cacheInfo */}, // Optional: empty + {/* instructions */} // Optional: empty + ) { + // Intialize register file info + // GRF + this->registerFileInfo.emplace( + RegisterFileType::GRF, + RegisterFileInfo( + 64 * 1024, // size in bits + {RegisterFileMode::Small, RegisterFileMode::Large}, // GRF modes + {128, 256} // registers per thread per mode + )); + // Initialize cache info + // L1 cache, XeCore level + this->cacheInfo.push_back( + CacheInfo(512 * 1024, 64, CacheHierarchyLevel::L1)); + // L2 cache, XeStack level + this->cacheInfo.push_back( + CacheInfo(512 * 1024, 64, CacheHierarchyLevel::L2)); + + // Add the instructions- + auto dpas = std::make_shared<DPASInstruction>(); + instructions.emplace(dpas->getInstructionKind(), dpas); + owned_instructions.push_back(dpas); + } +}; + +struct BMGuArch : public Xe2Plus { + // Maintaines ownership of the instructions owned by PVUarch + llvm::SmallVector<std::shared_ptr<Instruction>, 8> owned_instructions; + BMGuArch() + : Xe2Plus("bmg", // archName + "Battlemage Architecture", // archDescription + XeCoreInfo(8, SharedMemory(256 * 1024, 4), 8, 8), // xeCore + {/* registerFileInfo */}, // Optional: empty + {/* cacheInfo */}, // Optional: empty + {/* instructions */} // Optional: empty + ) { + // Intialize register file info + // GRF + this->registerFileInfo[RegisterFileType::GRF] = RegisterFileInfo( + 64 * 1024, // size in bits + {RegisterFileMode::Small, RegisterFileMode::Large}, // GRF modes + {128, 256} // registers per thread per mode + ); + // Initialize cache info + // L1 cache, XeCore level + this->cacheInfo.push_back( + CacheInfo(256 * 1024, 64, CacheHierarchyLevel::L1)); + // L2 cache, XeStack level + this->cacheInfo.push_back( + CacheInfo(18 * 1024 * 1024, 256, CacheHierarchyLevel::L2)); + + // Add the instructions + auto dpas = std::make_shared<DPASInstruction>(); + instructions.emplace(dpas->getInstructionKind(), dpas); + owned_instructions.push_back(dpas); + } +}; +} // namespace uArch +} // namespace xegpu +} // namespace mlir + +inline llvm::SmallVector<std::pair<uint32_t, uint32_t>, 16> +DPASInstruction::getSupportedShapes(Type dataType, MMAOpndKind matrixType) { + auto combineVectors = [](const llvm::SmallVector<uint32_t, 8> &a, + const llvm::SmallVector<uint32_t, 8> &b) + -> llvm::SmallVector<std::pair<uint32_t, uint32_t>, 16> { + llvm::SmallVector<std::pair<uint32_t, uint32_t>, 16> result; + for (unsigned x : a) { + for (unsigned y : b) { + result.emplace_back(x, y); + } + } + return result; + }; + + auto M = getSupportedM(dataType); + auto K = getSupportedK(dataType); + auto N = getSupportedN(dataType); + llvm::SmallVector<std::pair<unsigned, unsigned>, 16> resultMatrix; + + switch (matrixType) { + case MMAOpndKind::MatrixA: + resultMatrix = combineVectors(M, K); + break; + case MMAOpndKind::MatrixB: + resultMatrix = combineVectors(K, N); + break; + case MMAOpndKind::MatrixC: + resultMatrix = combineVectors(M, N); + break; + case MMAOpndKind::MatrixD: + resultMatrix = combineVectors(M, N); + break; + } + return resultMatrix; +} + +inline llvm::SmallVector<Type, 8> +DPASInstruction::getSupportedTypes(MLIRContext &context, + MMAOpndKind matrixType) { + Type bf16Type = BFloat16Type::get(&context); + Type f16Type = Float16Type::get(&context); + Type tf32Type = FloatTF32Type::get(&context); + Type f32Type = Float32Type::get(&context); + + switch (matrixType) { + case MMAOpndKind::MatrixA: + return {bf16Type, f16Type, tf32Type}; + case MMAOpndKind::MatrixB: + return {bf16Type, f16Type, tf32Type}; + case MMAOpndKind::MatrixC: + return {bf16Type, f16Type, f32Type}; + case MMAOpndKind::MatrixD: + return {bf16Type, f16Type, f32Type}; + } + return {}; +} + +inline bool DPASInstruction::checkSupportedTypes(Type AType, Type BType, + Type CType, Type DType) { + if (AType.isF16() || BType.isF16()) { + if (AType != BType || (CType && (!CType.isF32() && !CType.isF16())) || + (!DType.isF32() && !DType.isF16())) { + LDBG() << "Unsupported dpas combinations of Dst, Acc, A and B matrices."; + return false; + } + } else if (AType.isBF16() || BType.isBF16()) { + if (AType != BType || (CType && (!CType.isF32() && !CType.isBF16())) || + (!DType.isF32() && !DType.isBF16())) { + LDBG() << "Unsupported dpas combinations of Dst, Acc, A and B matrices."; + return false; + } + } else if (AType.isTF32() || BType.isTF32()) { + if (AType != BType || (CType && (!CType.isF32() && !DType.isF32())) || + (!DType.isF32())) { + LDBG() << "Unsupported dpas combinations of Dst, Acc, A and B matrices."; + return false; + } + } else if (!(AType.isInteger(2) || AType.isInteger(4) || + AType.isInteger(8)) && + !(BType.isInteger(2) || BType.isInteger(4) || + BType.isInteger(8))) { + LDBG() << "Unsupported dpas combinations of Dst, Acc, A and B matrices."; + return false; + } + + return true; +} + +inline bool DPASInstruction::checkSupportedShapesAndTypes( + std::pair<uint32_t, uint32_t> AShape, std::pair<uint32_t, uint32_t> BShape, + std::pair<uint32_t, uint32_t> CShape, std::pair<uint32_t, uint32_t> DShape, + Type AType, Type BType, Type CType, Type DType) { + auto supportedAShapes = getSupportedShapes(AType, MMAOpndKind::MatrixA); + auto supportedBShapes = getSupportedShapes(BType, MMAOpndKind::MatrixB); + auto supportedCShapes = getSupportedShapes(CType, MMAOpndKind::MatrixC); + auto supportedDShapes = getSupportedShapes(DType, MMAOpndKind::MatrixD); + return llvm::is_contained(supportedAShapes, AShape) && + llvm::is_contained(supportedBShapes, BShape) && + llvm::is_contained(supportedCShapes, CShape) && + llvm::is_contained(supportedDShapes, DShape) && + checkSupportedTypes(AType, BType, CType, DType); +} + +inline bool DPASInstruction::validate(std::pair<uint32_t, uint32_t> AShape, + std::pair<uint32_t, uint32_t> BShape, + std::pair<uint32_t, uint32_t> CShape, + std::pair<uint32_t, uint32_t> DShape, + Type AType, Type BType, Type CType, + Type DType) { + return checkSupportedShapesAndTypes(AShape, BShape, CShape, DShape, AType, + BType, CType, DType); +} + +inline llvm::SmallVector<uint32_t, 8> +DPASInstruction::getSupportedM(Type type) { + return {1, 2, 3, 4, 5, 6, 7, 8}; +} + +inline llvm::SmallVector<uint32_t, 8> +DPASInstruction::getSupportedK(Type type) { + // assert if data type is not int or float type + assert(type.isIntOrFloat() && "Matrix type must be int or float"); + auto bitWidth = type.getIntOrFloatBitWidth(); + uint32_t kSize = 0; + switch (bitWidth) { + case 2: + kSize = 64; + break; + case 4: + kSize = 64; + break; + case 8: + kSize = 32; + break; + case 16: + kSize = 16; + break; + case 32: + kSize = 8; + break; + default: + llvm_unreachable("Invalid int or float"); + } + return {kSize}; +} + +inline llvm::SmallVector<uint32_t, 8> +DPASInstruction::getSupportedN(Type type) { + return {16}; +} + +#endif // MLIR_DIALECT_XEGPU_UARCH_INTELGPUXE2_H diff --git a/mlir/include/mlir/Dialect/XeGPU/uArch/uArchBase.h b/mlir/include/mlir/Dialect/XeGPU/uArch/uArchBase.h new file mode 100644 index 0000000..955994e --- /dev/null +++ b/mlir/include/mlir/Dialect/XeGPU/uArch/uArchBase.h @@ -0,0 +1,265 @@ +//===- uArch.h --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// \file +// Base uArch definition for different architectures. +// +// +//===----------------------------------------------------------------------===// +#ifndef MLIR_DIALECT_XEGPU_UARCH_UARCHBASE_H +#define MLIR_DIALECT_XEGPU_UARCH_UARCHBASE_H + +#include <any> +#include <functional> +#include <iostream> +#include <map> +#include <mutex> +#include <shared_mutex> +#include <tuple> + +#include "mlir/IR/Types.h" +#include "llvm/ADT/SmallVector.h" + +namespace mlir { +namespace xegpu { +namespace uArch { + +// An enum class to represent the scope of an instruction +enum class InstructionScope { Lane, Subgroup, Workgroup, Cluster }; +enum class InstructionKind { + DPAS, // Dot Product Accumulate Systolic (DPAS) is a matrix + // multiply-add operation + // @TODO: Add more instructions as needed +}; + +// A struct to represent basic information about an instruction. +// The primary purpose of the Instruction struct is to provide a generic way to +// represent information about an instruction and to use this information to +// generate the uArch. Specifc instruction in a uArch can inherit from this +// struct and add more fields as needed. +struct Instruction { + Instruction(InstructionKind kind, InstructionScope scope) + : instKind(kind), scope(scope) {} + + virtual ~Instruction() = default; + // Get methods + InstructionKind getInstructionKind() { return instKind; } + InstructionScope getScope() { return scope; } + static llvm::StringRef toString(InstructionKind instKind) { + switch (instKind) { + case InstructionKind::DPAS: + return "dpas"; + } + llvm_unreachable("Unknown InstructionKind"); + } + + static std::optional<InstructionKind> + parseInstructionKind(llvm::StringRef str) { + if (str.equals_insensitive("dpas")) + return InstructionKind::DPAS; + return std::nullopt; + } + +protected: + InstructionKind instKind; // Specific InstructionKind (e.g., DPAS) + InstructionScope scope; // scope of the instruction (e.g., lane, subgroup, + // workgroup, cluster) + // @TODO: Add more fields as needed +}; + +enum class RegisterFileMode : uint8_t { Small, Large }; +enum class RegisterFileType : uint8_t { GRF, ARF }; + +// A struct to represent register file information +struct RegisterFileInfo { + // Constructor + RegisterFileInfo() = default; + RegisterFileInfo(uint32_t size, + const llvm::SmallVector<RegisterFileMode, 4> &mode, + const llvm::SmallVector<uint32_t, 4> &numRegs) + : size(size), mode(mode), numRegsPerThreadPerMode(numRegs) {} + + // Get methods + uint32_t getSize() const { return size; } + + const llvm::SmallVector<RegisterFileMode, 4> &getModes() const { + return mode; + } + + const llvm::SmallVector<uint32_t, 4> &getNumRegsPerThreadPerMode() const { + return numRegsPerThreadPerMode; + } + +protected: + uint32_t size; // size per register in bits + llvm::SmallVector<RegisterFileMode, 4> + mode; // e.g., "small", "large" GRF modes + llvm::SmallVector<uint32_t, 4> + numRegsPerThreadPerMode; // number of registers per thread per mode +}; + +enum class CacheHierarchyLevel { L1 = 1, L2 = 2, L3 = 3 }; + +// A struct to represent cache information +struct CacheInfo { + // Constructor + CacheInfo() = default; + CacheInfo(uint32_t size, uint32_t line_size, + CacheHierarchyLevel hierarchy_level) + : size(size), line_size(line_size), hierarchy_level(hierarchy_level) {} + + virtual ~CacheInfo() = default; + + // Get methods + uint32_t getSize() const { return size; } + uint32_t getLineSize() const { return line_size; } + CacheHierarchyLevel getHierarchyLevel() const { return hierarchy_level; } + +protected: + uint32_t size; + uint32_t line_size; + CacheHierarchyLevel hierarchy_level; + // @TODO: Add more fields as needed (e.g., associativity, num_banks, + // bank_size, num_ports, port_width, bank_conflicts, hierarchy_level, + // latency, throughput, bandwidth) +}; + +// A struct to represent the uArch +// This struct is used to represent the microarchitecture of a target device. +struct uArch { + // Constructor + uArch( + const std::string &name, const std::string &description, + const std::map<RegisterFileType, RegisterFileInfo> ®isterFileInfo = {}, + const llvm::SmallVector<CacheInfo, 4> &cacheInfo = {}, + const std::map<InstructionKind, std::shared_ptr<Instruction>> + &instructions = {}) + : name(name), description(description), + registerFileInfo(registerFileInfo), cacheInfo(cacheInfo), + instructions(instructions) {} + + // Get methods + const std::string &getName() const { return name; } + + const std::string &getDescription() const { return description; } + + const std::map<RegisterFileType, RegisterFileInfo> & + getRegisterFileInfo() const { + return registerFileInfo; + } + + const llvm::SmallVector<CacheInfo, 4> &getCacheInfo() const { + return cacheInfo; + } + + const std::map<InstructionKind, std::shared_ptr<Instruction>> & + getInstructions() const { + return instructions; + } + + // Get the name of the supported instruction names for that + // architecture. It returns the names of the instructions added to the uArch. + llvm::SmallVector<StringRef, 8> getSupportedInstructionNames() const { + llvm::SmallVector<StringRef, 8> instructionNames; + for (const auto &inst : instructions) { + instructionNames.push_back(Instruction::toString(inst.first)); + } + return instructionNames; + } + + // Checks if an instruction is supported in this uArch + bool checkSupportedInstruction(InstructionKind instr) const { + return instructions.find(instr) != instructions.end(); + } + +protected: + std::string name; // Name of the uArch, similar to target triple + std::string description; + std::map<RegisterFileType, RegisterFileInfo> registerFileInfo; + llvm::SmallVector<CacheInfo, 4> cacheInfo; + std::map<InstructionKind, std::shared_ptr<Instruction>> + instructions; // set of instructions supported by the uArch +}; + +// A struct to represent shared memory information +struct SharedMemory { + // Constructor + SharedMemory(uint32_t size, uint32_t alignment) + : size(size), alignment(alignment) {} + + // Get methods + uint32_t getSize() const { return size; } + uint32_t getAlignment() const { return alignment; } + +protected: + uint32_t size; // in bytes + uint32_t alignment; // in bytes + // @TODO: Add more fields as needed (e.g., latency, throughput, bandwidth) +}; + +struct XeCoreInfo { + uint32_t num_threads; + SharedMemory shared_memory; + uint32_t num_vector_units; + uint32_t num_matrix_units; + + XeCoreInfo(uint32_t num_threads, const SharedMemory &shared_memory, + uint32_t num_vector_units, uint32_t num_matrix_units) + : num_threads(num_threads), shared_memory(shared_memory), + num_vector_units(num_vector_units), num_matrix_units(num_matrix_units) { + } +}; + +//===----------------------------------------------------------------------===// +// Interfaces +//===----------------------------------------------------------------------===// +enum class MMAOpndKind { MatrixA, MatrixB, MatrixC, MatrixD }; +struct MMAInstructionInterface { + // Get supported Matrix shapes + virtual llvm::SmallVector<std::pair<uint32_t, uint32_t>, 16> + getSupportedShapes(Type dataType, MMAOpndKind matrixType) = 0; + // @TODO: This method takes an context object as a parameter, this is to + // create the Type objects from the same context. Since type objects are + // uniqued in a specific context, to do things like "aType == bType" (where + // aType and bType are both same type) kind of checks, the both types should + // be from the same context. + // + // One alternative to this is to create enum to represent each types, but this + // adds an extra burden to user to convert these enums to specific types. In + // fact the utility that would convert enumToType() and vice versa would still + // have to use the context object. + // + // Untill we have a better solution, we stick to passing context object to + // this method. + virtual llvm::SmallVector<Type, 8> + getSupportedTypes(MLIRContext &context, MMAOpndKind matrixType) = 0; + virtual bool + checkSupportedShapesAndTypes(std::pair<uint32_t, uint32_t> AShape, + std::pair<uint32_t, uint32_t> BShape, + std::pair<uint32_t, uint32_t> CShape, + std::pair<uint32_t, uint32_t> DShape, Type AType, + Type BType, Type CType, Type DType) = 0; + virtual bool checkSupportedTypes(Type AType, Type BType, Type CType, + Type DType) = 0; + virtual bool validate(std::pair<uint32_t, uint32_t> AShape, + std::pair<uint32_t, uint32_t> BShape, + std::pair<uint32_t, uint32_t> CShape, + std::pair<uint32_t, uint32_t> DShape, Type AType, + Type BType, Type CType, Type DType) = 0; + virtual llvm::SmallVector<uint32_t, 8> getSupportedM(Type type) = 0; + virtual llvm::SmallVector<uint32_t, 8> getSupportedK(Type type) = 0; + virtual llvm::SmallVector<uint32_t, 8> getSupportedN(Type type) = 0; + + virtual ~MMAInstructionInterface() = default; +}; + +} // namespace uArch +} // namespace xegpu +} // namespace mlir + +#endif // MLIR_DIALECT_XEGPU_UARCH_UARCHBASE_H diff --git a/mlir/lib/Dialect/XeGPU/IR/XeGPUDialect.cpp b/mlir/lib/Dialect/XeGPU/IR/XeGPUDialect.cpp index 94c5509..9beb22d 100644 --- a/mlir/lib/Dialect/XeGPU/IR/XeGPUDialect.cpp +++ b/mlir/lib/Dialect/XeGPU/IR/XeGPUDialect.cpp @@ -12,6 +12,7 @@ #include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/XeGPU/IR/XeGPU.h" #include "mlir/Dialect/XeGPU/IR/XeGPUTargetInfo.h" +#include "mlir/Dialect/XeGPU/uArch/IntelGpuXe2.h" #include "mlir/IR/Builders.h" #include "mlir/IR/DialectImplementation.h" #include "llvm/ADT/TypeSwitch.h" diff --git a/orc-rt/include/orc-rt/SPSWrapperFunction.h b/orc-rt/include/orc-rt/SPSWrapperFunction.h index 824e009..dc68822 100644 --- a/orc-rt/include/orc-rt/SPSWrapperFunction.h +++ b/orc-rt/include/orc-rt/SPSWrapperFunction.h @@ -110,7 +110,7 @@ public: } template <typename ArgTuple> - std::optional<ArgTuple> deserialize(WrapperFunctionBuffer ArgBytes) { + std::optional<ArgTuple> deserialize(const WrapperFunctionBuffer &ArgBytes) { assert(!ArgBytes.getOutOfBandError() && "Should not attempt to deserialize out-of-band error"); SPSInputBuffer IB(ArgBytes.data(), ArgBytes.size()); diff --git a/orc-rt/include/orc-rt/WrapperFunction.h b/orc-rt/include/orc-rt/WrapperFunction.h index c43f1c5..6e8b84e 100644 --- a/orc-rt/include/orc-rt/WrapperFunction.h +++ b/orc-rt/include/orc-rt/WrapperFunction.h @@ -382,8 +382,7 @@ struct WrapperFunction { if (ArgBytes.getOutOfBandError()) return Return(Session, CallCtx, ArgBytes.release()); - if (auto Args = - S.arguments().template deserialize<ArgTuple>(std::move(ArgBytes))) + if (auto Args = S.arguments().template deserialize<ArgTuple>(ArgBytes)) std::apply(HandlerTraits::forwardArgsAsRequested(bind_front( std::forward<Handler>(H), detail::StructuredYield<RetTupleType, Serializer>( diff --git a/orc-rt/unittests/SPSWrapperFunctionTest.cpp b/orc-rt/unittests/SPSWrapperFunctionTest.cpp index d0f06e8..ed085f2 100644 --- a/orc-rt/unittests/SPSWrapperFunctionTest.cpp +++ b/orc-rt/unittests/SPSWrapperFunctionTest.cpp @@ -95,6 +95,29 @@ TEST(SPSWrapperFunctionUtilsTest, BinaryOpViaFunctionPointer) { EXPECT_EQ(Result, 42); } +static void +round_trip_string_via_span_sps_wrapper(orc_rt_SessionRef Session, void *CallCtx, + orc_rt_WrapperFunctionReturn Return, + orc_rt_WrapperFunctionBuffer ArgBytes) { + SPSWrapperFunction<SPSString(SPSString)>::handle( + Session, CallCtx, Return, ArgBytes, + [](move_only_function<void(std::string)> Return, span<const char> S) { + Return({S.data(), S.size()}); + }); +} + +TEST(SPSWrapperFunctionUtilsTest, RoundTripStringViaSpan) { + /// Test that the SPSWrapperFunction<...>::handle call in + /// round_trip_string_via_span_sps_wrapper can deserialize into a usable + /// span<const char>. + std::string Result; + SPSWrapperFunction<SPSString(SPSString)>::call( + DirectCaller(nullptr, round_trip_string_via_span_sps_wrapper), + [&](Expected<std::string> R) { Result = cantFail(std::move(R)); }, + std::string_view("hello, world!")); + EXPECT_EQ(Result, "hello, world!"); +} + static void improbable_feat_sps_wrapper(orc_rt_SessionRef Session, void *CallCtx, orc_rt_WrapperFunctionReturn Return, |