470 lines · plain
1// RUN: llvm-tblgen -gen-directive-decl -I %p/../../include %s | FileCheck -match-full-lines %s2// RUN: llvm-tblgen -gen-directive-impl -I %p/../../include %s | FileCheck -match-full-lines %s -check-prefix=IMPL3 4include "llvm/Frontend/Directive/DirectiveBase.td"5 6def TestDirectiveLanguage : DirectiveLanguage {7 let name = "Tdl";8 9 let cppNamespace = "tdl";10 let directivePrefix = "TDLD_";11 let clausePrefix = "TDLC_";12 let makeEnumAvailableInNamespace = 1;13 let enableBitmaskEnumInNamespace = 1;14 let flangClauseBaseClass = "TdlClause";15}16 17def TDLCV_vala : EnumVal<"vala",1,1> {}18def TDLCV_valb : EnumVal<"valb",2,1> {}19def TDLCV_valc : EnumVal<"valc",3,0> { let isDefault = 1; }20 21def TDLC_ClauseA : Clause<[Spelling<"clausea">]> {22 let enumClauseValue = "AKind";23 let allowedClauseValues = [24 TDLCV_vala,25 TDLCV_valb,26 TDLCV_valc27 ];28}29 30def TDLC_ClauseB : Clause<[Spelling<"clauseb">]> {31 let flangClass = "IntExpr";32 let isValueOptional = 1;33 let isDefault = 1;34}35 36def TDLC_ClauseC : Clause<[Spelling<"clausec">, Spelling<"ccccccc">]> {37 let flangClass = "IntExpr";38 let isValueList = 1;39}40 41def TDL_DirA : Directive<[Spelling<"dira">]> {42 let allowedClauses = [43 VersionedClause<TDLC_ClauseA>,44 VersionedClause<TDLC_ClauseB>45 ];46 let isDefault = 1;47 let association = AS_None;48 let category = CA_Executable;49}50 51// CHECK: #ifndef LLVM_Tdl_INC52// CHECK-NEXT: #define LLVM_Tdl_INC53// CHECK-EMPTY:54// CHECK-NEXT: #include "llvm/ADT/ArrayRef.h"55// CHECK-NEXT: #include "llvm/ADT/BitmaskEnum.h"56// CHECK-NEXT: #include "llvm/ADT/Sequence.h"57// CHECK-NEXT: #include "llvm/ADT/StringRef.h"58// CHECK-NEXT: #include "llvm/Frontend/Directive/Spelling.h"59// CHECK-NEXT: #include "llvm/Support/Compiler.h"60// CHECK-NEXT: #include <cstddef>61// CHECK-NEXT: #include <utility>62// CHECK-EMPTY:63// CHECK-NEXT: namespace llvm {64// CHECK-EMPTY:65// CHECK-NEXT: namespace tdl {66// CHECK-EMPTY:67// CHECK-NEXT: LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();68// CHECK-EMPTY:69// CHECK-NEXT: enum class Association {70// CHECK-NEXT: Block,71// CHECK-NEXT: First_ = Block,72// CHECK-NEXT: Declaration,73// CHECK-NEXT: Delimited,74// CHECK-NEXT: LoopNest,75// CHECK-NEXT: LoopSeq,76// CHECK-NEXT: None,77// CHECK-NEXT: Separating,78// CHECK-NEXT: Last_ = Separating,79// CHECK-NEXT: };80// CHECK-EMPTY:81// CHECK-NEXT: static constexpr std::size_t Association_enumSize = 7;82// CHECK-EMPTY:83// CHECK-NEXT: enum class Category {84// CHECK-NEXT: Declarative,85// CHECK-NEXT: First_ = Declarative,86// CHECK-NEXT: Executable,87// CHECK-NEXT: Informational,88// CHECK-NEXT: Meta,89// CHECK-NEXT: Subsidiary,90// CHECK-NEXT: Utility,91// CHECK-NEXT: Last_ = Utility,92// CHECK-NEXT: };93// CHECK-EMPTY:94// CHECK-NEXT: static constexpr std::size_t Category_enumSize = 6;95// CHECK-EMPTY:96// CHECK-NEXT: enum class SourceLanguage : uint32_t {97// CHECK-NEXT: C = 1U,98// CHECK-NEXT: Fortran = 2U,99// CHECK-NEXT: LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Fortran)100// CHECK-NEXT: };101// CHECK-EMPTY:102// CHECK-NEXT: static constexpr std::size_t SourceLanguage_enumSize = 2;103// CHECK-EMPTY:104// CHECK-NEXT: enum class Directive {105// CHECK-NEXT: TDLD_dira,106// CHECK-NEXT: First_ = TDLD_dira,107// CHECK-NEXT: Last_ = TDLD_dira,108// CHECK-NEXT: };109// CHECK-EMPTY:110// CHECK-NEXT: static constexpr std::size_t Directive_enumSize = 1;111// CHECK-EMPTY:112// CHECK-NEXT: constexpr auto TDLD_dira = Directive::TDLD_dira;113// CHECK-EMPTY:114// CHECK-NEXT: enum class Clause {115// CHECK-NEXT: TDLC_clausea,116// CHECK-NEXT: First_ = TDLC_clausea,117// CHECK-NEXT: TDLC_clauseb,118// CHECK-NEXT: TDLC_clausec,119// CHECK-NEXT: Last_ = TDLC_clausec,120// CHECK-NEXT: };121// CHECK-EMPTY:122// CHECK-NEXT: static constexpr std::size_t Clause_enumSize = 3;123// CHECK-EMPTY:124// CHECK-NEXT: constexpr auto TDLC_clausea = Clause::TDLC_clausea;125// CHECK-NEXT: constexpr auto TDLC_clauseb = Clause::TDLC_clauseb;126// CHECK-NEXT: constexpr auto TDLC_clausec = Clause::TDLC_clausec;127// CHECK-EMPTY:128// CHECK-NEXT: enum class AKind {129// CHECK-NEXT: TDLCV_vala=1,130// CHECK-NEXT: TDLCV_valb=2,131// CHECK-NEXT: TDLCV_valc=3,132// CHECK-NEXT: };133// CHECK-EMPTY:134// CHECK-NEXT: constexpr auto TDLCV_vala = AKind::TDLCV_vala;135// CHECK-NEXT: constexpr auto TDLCV_valb = AKind::TDLCV_valb;136// CHECK-NEXT: constexpr auto TDLCV_valc = AKind::TDLCV_valc;137// CHECK-EMPTY:138// CHECK-NEXT: // Enumeration helper functions139// CHECK-NEXT: LLVM_ABI std::pair<Directive, directive::VersionRange> getTdlDirectiveKindAndVersions(StringRef Str);140// CHECK-NEXT: inline Directive getTdlDirectiveKind(StringRef Str) {141// CHECK-NEXT: return getTdlDirectiveKindAndVersions(Str).first;142// CHECK-NEXT: }143// CHECK-EMPTY:144// CHECK-NEXT: LLVM_ABI StringRef getTdlDirectiveName(Directive D, unsigned Ver = 0);145// CHECK-EMPTY:146// CHECK-NEXT: LLVM_ABI std::pair<Clause, directive::VersionRange> getTdlClauseKindAndVersions(StringRef Str);147// CHECK-EMPTY:148// CHECK-NEXT: inline Clause getTdlClauseKind(StringRef Str) {149// CHECK-NEXT: return getTdlClauseKindAndVersions(Str).first;150// CHECK-NEXT: }151// CHECK-EMPTY:152// CHECK-NEXT: LLVM_ABI StringRef getTdlClauseName(Clause C, unsigned Ver = 0);153// CHECK-EMPTY:154// CHECK-NEXT: /// Return true if \p C is a valid clause for \p D in version \p Version.155// CHECK-NEXT: LLVM_ABI bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);156// CHECK-EMPTY:157// CHECK-NEXT: constexpr std::size_t getMaxLeafCount() { return 0; }158// CHECK-NEXT: LLVM_ABI Association getDirectiveAssociation(Directive D);159// CHECK-NEXT: LLVM_ABI Category getDirectiveCategory(Directive D);160// CHECK-NEXT: LLVM_ABI SourceLanguage getDirectiveLanguages(Directive D);161// CHECK-NEXT: LLVM_ABI AKind getAKind(StringRef Str);162// CHECK-NEXT: LLVM_ABI StringRef getTdlAKindName(AKind x);163// CHECK-EMPTY:164// CHECK-NEXT: } // namespace tdl165// CHECK-EMPTY:166// CHECK-NEXT: template <> struct enum_iteration_traits<tdl::Association> {167// CHECK-NEXT: static constexpr bool is_iterable = true;168// CHECK-NEXT: };169// CHECK-EMPTY:170// CHECK-NEXT: template <> struct enum_iteration_traits<tdl::Category> {171// CHECK-NEXT: static constexpr bool is_iterable = true;172// CHECK-NEXT: };173// CHECK-EMPTY:174// CHECK-NEXT: template <> struct enum_iteration_traits<tdl::Directive> {175// CHECK-NEXT: static constexpr bool is_iterable = true;176// CHECK-NEXT: };177// CHECK-EMPTY:178// CHECK-NEXT: template <> struct enum_iteration_traits<tdl::Clause> {179// CHECK-NEXT: static constexpr bool is_iterable = true;180// CHECK-NEXT: };181// CHECK-EMPTY:182// CHECK-NEXT: } // namespace llvm183// CHECK-EMPTY:184// CHECK-NEXT: #endif // LLVM_Tdl_INC185 186 187// IMPL: #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS188// IMPL-NEXT: #undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS189// IMPL-EMPTY:190// IMPL-NEXT: namespace llvm::tdl {191// IMPL-EMPTY:192// IMPL-NEXT: // Sets for dira193// IMPL-EMPTY:194// IMPL-NEXT: static allowedClauses_TDLD_dira {195// IMPL-NEXT: Clause::TDLC_clausea,196// IMPL-NEXT: Clause::TDLC_clauseb,197// IMPL-NEXT: };198// IMPL-EMPTY:199// IMPL-NEXT: static allowedOnceClauses_TDLD_dira {200// IMPL-NEXT: };201// IMPL-EMPTY:202// IMPL-NEXT: static allowedExclusiveClauses_TDLD_dira {203// IMPL-NEXT: };204// IMPL-EMPTY:205// IMPL-NEXT: static requiredClauses_TDLD_dira {206// IMPL-NEXT: };207// IMPL-EMPTY:208// IMPL-NEXT: } // namespace llvm::tdl209// IMPL-EMPTY:210// IMPL-NEXT: #endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS211// IMPL-EMPTY:212// IMPL-NEXT: #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP213// IMPL-NEXT: #undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP214// IMPL-EMPTY:215// IMPL-NEXT: {216// IMPL-NEXT: {llvm::tdl::Directive::TDLD_dira,217// IMPL-NEXT: {218// IMPL-NEXT: llvm::tdl::allowedClauses_TDLD_dira,219// IMPL-NEXT: llvm::tdl::allowedOnceClauses_TDLD_dira,220// IMPL-NEXT: llvm::tdl::allowedExclusiveClauses_TDLD_dira,221// IMPL-NEXT: llvm::tdl::requiredClauses_TDLD_dira,222// IMPL-NEXT: }223// IMPL-NEXT: },224// IMPL-NEXT: }225// IMPL-EMPTY:226// IMPL-NEXT: #endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP227// IMPL-EMPTY:228// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES229// IMPL-NEXT: #undef GEN_FLANG_CLAUSE_PARSER_CLASSES230// IMPL-EMPTY:231// IMPL-NEXT: EMPTY_CLASS(Clausea);232// IMPL-NEXT: WRAPPER_CLASS(Clauseb, std::optional<IntExpr>);233// IMPL-NEXT: WRAPPER_CLASS(Clausec, std::list<IntExpr>);234// IMPL-EMPTY:235// IMPL-NEXT: #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES236// IMPL-EMPTY:237// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST238// IMPL-NEXT: #undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST239// IMPL-EMPTY:240// IMPL-NEXT: Clausea241// IMPL-NEXT: , Clauseb242// IMPL-NEXT: , Clausec243// IMPL-EMPTY:244// IMPL-NEXT: #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST245// IMPL-EMPTY:246// IMPL-NEXT: #ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES247// IMPL-NEXT: #undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES248// IMPL-EMPTY:249// IMPL-NEXT: NODE(TdlClause, Clausea)250// IMPL-NEXT: NODE(TdlClause, Clauseb)251// IMPL-NEXT: NODE(TdlClause, Clausec)252// IMPL-EMPTY:253// IMPL-NEXT: #endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES254// IMPL-EMPTY:255// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSE_UNPARSE256// IMPL-NEXT: #undef GEN_FLANG_CLAUSE_UNPARSE257// IMPL-EMPTY:258// IMPL-NEXT: void Before(const TdlClause::Clausea &) { Word("CLAUSEA"); }259// IMPL-NEXT: void Unparse(const TdlClause::Clauseb &x) {260// IMPL-NEXT: Word("CLAUSEB");261// IMPL-NEXT: Walk("(", x.v, ")");262// IMPL-NEXT: }263// IMPL-NEXT: void Unparse(const TdlClause::Clausec &x) {264// IMPL-NEXT: Word("CLAUSEC");265// IMPL-NEXT: Put("(");266// IMPL-NEXT: Walk(x.v, ",");267// IMPL-NEXT: Put(")");268// IMPL-NEXT: }269// IMPL-EMPTY:270// IMPL-NEXT: #endif // GEN_FLANG_CLAUSE_UNPARSE271// IMPL-EMPTY:272// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSE_CHECK_ENTER273// IMPL-NEXT: #undef GEN_FLANG_CLAUSE_CHECK_ENTER274// IMPL-EMPTY:275// IMPL-NEXT: void Enter(const parser::TdlClause::Clausea &);276// IMPL-NEXT: void Enter(const parser::TdlClause::Clauseb &);277// IMPL-NEXT: void Enter(const parser::TdlClause::Clausec &);278// IMPL-EMPTY:279// IMPL-NEXT: #endif // GEN_FLANG_CLAUSE_CHECK_ENTER280// IMPL-EMPTY:281// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSE_PARSER_KIND_MAP282// IMPL-NEXT: #undef GEN_FLANG_CLAUSE_PARSER_KIND_MAP283// IMPL-EMPTY:284// IMPL-NEXT: if constexpr (std::is_same_v<A, parser::TdlClause::Clausea>)285// IMPL-NEXT: return llvm::tdl::Clause::TDLC_clausea;286// IMPL-NEXT: if constexpr (std::is_same_v<A, parser::TdlClause::Clauseb>)287// IMPL-NEXT: return llvm::tdl::Clause::TDLC_clauseb;288// IMPL-NEXT: if constexpr (std::is_same_v<A, parser::TdlClause::Clausec>)289// IMPL-NEXT: return llvm::tdl::Clause::TDLC_clausec;290// IMPL-NEXT: llvm_unreachable("Invalid Tdl Parser clause");291// IMPL-EMPTY:292// IMPL-NEXT: #endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP293// IMPL-EMPTY:294// IMPL-NEXT: #ifdef GEN_FLANG_CLAUSES_PARSER295// IMPL-NEXT: #undef GEN_FLANG_CLAUSES_PARSER296// IMPL-EMPTY:297// IMPL-NEXT: TYPE_PARSER(298// IMPL-NEXT: "clausec" >> construct<TdlClause>(construct<TdlClause::Clausec>(parenthesized(nonemptyList(Parser<IntExpr>{})))) || 299// IMPL-NEXT: "clauseb" >> construct<TdlClause>(construct<TdlClause::Clauseb>(maybe(parenthesized(Parser<IntExpr>{})))) ||300// IMPL-NEXT: "clausea" >> construct<TdlClause>(construct<TdlClause::Clausea>()) ||301// IMPL-NEXT: "ccccccc" >> construct<TdlClause>(construct<TdlClause::Clausec>(parenthesized(nonemptyList(Parser<IntExpr>{}))))302// IMPL-NEXT: )303// IMPL-EMPTY:304// IMPL-NEXT: #endif // GEN_FLANG_CLAUSES_PARSER305// IMPL-EMPTY:306// IMPL-NEXT: #ifdef GEN_CLANG_CLAUSE_CLASS307// IMPL-NEXT: #undef GEN_CLANG_CLAUSE_CLASS308// IMPL-EMPTY:309// IMPL-NEXT: #ifndef CLAUSE310// IMPL-NEXT: #define CLAUSE(Enum, Str, Implicit)311// IMPL-NEXT: #endif312// IMPL-NEXT: #ifndef CLAUSE_CLASS313// IMPL-NEXT: #define CLAUSE_CLASS(Enum, Str, Class)314// IMPL-NEXT: #endif315// IMPL-NEXT: #ifndef CLAUSE_NO_CLASS316// IMPL-NEXT: #define CLAUSE_NO_CLASS(Enum, Str)317// IMPL-NEXT: #endif318// IMPL-EMPTY:319// IMPL-NEXT: #define __CLAUSE(Name, Class) \320// IMPL-NEXT: CLAUSE(TDLC_##Name, #Name, /* Implicit */ false) \321// IMPL-NEXT: CLAUSE_CLASS(TDLC_##Name, #Name, Class)322// IMPL-NEXT: #define __CLAUSE_NO_CLASS(Name) \323// IMPL-NEXT: CLAUSE(TDLC_##Name, #Name, /* Implicit */ false) \324// IMPL-NEXT: CLAUSE_NO_CLASS(TDLC_##Name, #Name)325// IMPL-NEXT: #define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class) \326// IMPL-NEXT: CLAUSE(TDLC_##Name, Str, /* Implicit */ true) \327// IMPL-NEXT: CLAUSE_CLASS(TDLC_##Name, Str, Class)328// IMPL-NEXT: #define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str) \329// IMPL-NEXT: CLAUSE(TDLC_##Name, Str, /* Implicit */ true) \330// IMPL-NEXT: CLAUSE_NO_CLASS(TDLC_##Name, Str)331// IMPL-EMPTY:332// IMPL-NEXT: __CLAUSE_NO_CLASS(clausea)333// IMPL-NEXT: __CLAUSE_NO_CLASS(clauseb)334// IMPL-NEXT: __CLAUSE_NO_CLASS(clausec)335// IMPL-EMPTY:336// IMPL-NEXT: #undef __IMPLICIT_CLAUSE_NO_CLASS337// IMPL-NEXT: #undef __IMPLICIT_CLAUSE_CLASS338// IMPL-NEXT: #undef __CLAUSE_NO_CLASS339// IMPL-NEXT: #undef __CLAUSE340// IMPL-NEXT: #undef CLAUSE_NO_CLASS341// IMPL-NEXT: #undef CLAUSE_CLASS342// IMPL-NEXT: #undef CLAUSE343// IMPL-EMPTY:344// IMPL-NEXT: #endif // GEN_CLANG_CLAUSE_CLASS345// IMPL-EMPTY:346 347// IMPL: #ifdef GEN_DIRECTIVES_IMPL348// IMPL-NEXT: #undef GEN_DIRECTIVES_IMPL349// IMPL-EMPTY:350// IMPL-NEXT: #include "llvm/Frontend/Directive/Spelling.h"351// IMPL-NEXT: #include "llvm/Support/ErrorHandling.h"352// IMPL-NEXT: #include <utility>353// IMPL-EMPTY:354// IMPL-NEXT: std::pair<llvm::tdl::Directive, llvm::directive::VersionRange> llvm::tdl::getTdlDirectiveKindAndVersions(llvm::StringRef Str) {355// IMPL-NEXT: directive::VersionRange All; // Default-initialized to "all versions"356// IMPL-NEXT: return StringSwitch<std::pair<Directive, directive::VersionRange>>(Str)357// IMPL-NEXT: .Case("dira", {TDLD_dira, All})358// IMPL-NEXT: .Default({TDLD_dira, All});359// IMPL-NEXT: }360// IMPL-EMPTY:361// IMPL-NEXT: llvm::StringRef llvm::tdl::getTdlDirectiveName(llvm::tdl::Directive Kind, unsigned Version) {362// IMPL-NEXT: switch (Kind) {363// IMPL-NEXT: case TDLD_dira:364// IMPL-NEXT: return "dira";365// IMPL-NEXT: }366// IMPL-NEXT: llvm_unreachable("Invalid Tdl Directive kind");367// IMPL-NEXT: }368// IMPL-EMPTY:369// IMPL-NEXT: std::pair<llvm::tdl::Clause, llvm::directive::VersionRange> llvm::tdl::getTdlClauseKindAndVersions(llvm::StringRef Str) {370// IMPL-NEXT: directive::VersionRange All; // Default-initialized to "all versions"371// IMPL-NEXT: return StringSwitch<std::pair<Clause, directive::VersionRange>>(Str)372// IMPL-NEXT: .Case("clausea", {TDLC_clausea, All})373// IMPL-NEXT: .Case("clauseb", {TDLC_clauseb, All})374// IMPL-NEXT: .Case("clausec", {TDLC_clausec, All})375// IMPL-NEXT: .Case("ccccccc", {TDLC_clausec, All})376// IMPL-NEXT: .Default({TDLC_clauseb, All});377// IMPL-NEXT: }378// IMPL-EMPTY:379// IMPL-NEXT: llvm::StringRef llvm::tdl::getTdlClauseName(llvm::tdl::Clause Kind, unsigned Version) {380// IMPL-NEXT: switch (Kind) {381// IMPL-NEXT: case TDLC_clausea:382// IMPL-NEXT: return "clausea";383// IMPL-NEXT: case TDLC_clauseb:384// IMPL-NEXT: return "clauseb";385// IMPL-NEXT: case TDLC_clausec: {386// IMPL-NEXT: static constexpr llvm::directive::Spelling TDLC_clausec_spellings[] = {387// IMPL-NEXT: {"clausec", {0, 2147483647}},388// IMPL-NEXT: {"ccccccc", {0, 2147483647}},389// IMPL-NEXT: };390// IMPL-NEXT: return llvm::directive::FindName(TDLC_clausec_spellings, Version);391// IMPL-NEXT: }392// IMPL-NEXT: }393// IMPL-NEXT: llvm_unreachable("Invalid Tdl Clause kind");394// IMPL-NEXT: }395// IMPL-EMPTY:396// IMPL-NEXT: llvm::tdl::AKind llvm::tdl::getAKind(llvm::StringRef Str) {397// IMPL-NEXT: return StringSwitch<AKind>(Str)398// IMPL-NEXT: .Case("vala",TDLCV_vala)399// IMPL-NEXT: .Case("valb",TDLCV_valb)400// IMPL-NEXT: .Case("valc",TDLCV_valc)401// IMPL-NEXT: .Default(TDLCV_valc);402// IMPL-NEXT: }403// IMPL-EMPTY:404// IMPL-NEXT: llvm::StringRef llvm::tdl::getTdlAKindName(llvm::tdl::AKind x) {405// IMPL-NEXT: switch (x) {406// IMPL-NEXT: case TDLCV_vala:407// IMPL-NEXT: return "vala";408// IMPL-NEXT: case TDLCV_valb:409// IMPL-NEXT: return "valb";410// IMPL-NEXT: case TDLCV_valc:411// IMPL-NEXT: return "valc";412// IMPL-NEXT: }413// IMPL-NEXT: llvm_unreachable("Invalid Tdl AKind kind");414// IMPL-NEXT: }415// IMPL-EMPTY:416// IMPL-NEXT: bool llvm::tdl::isAllowedClauseForDirective(llvm::tdl::Directive D, llvm::tdl::Clause C, unsigned Version) {417// IMPL-NEXT: assert(unsigned(D) <= Directive_enumSize);418// IMPL-NEXT: assert(unsigned(C) <= Clause_enumSize);419// IMPL-NEXT: switch (D) {420// IMPL-NEXT: case TDLD_dira:421// IMPL-NEXT: switch (C) {422// IMPL-NEXT: case TDLC_clausea:423// IMPL-NEXT: return 1 <= Version && 2147483647 >= Version;424// IMPL-NEXT: case TDLC_clauseb:425// IMPL-NEXT: return 1 <= Version && 2147483647 >= Version;426// IMPL-NEXT: default:427// IMPL-NEXT: return false;428// IMPL-NEXT: }429// IMPL-NEXT: break;430// IMPL-NEXT: }431// IMPL-NEXT: llvm_unreachable("Invalid Tdl Directive kind");432// IMPL-NEXT: }433// IMPL-EMPTY:434// IMPL-NEXT: llvm::tdl::Association llvm::tdl::getDirectiveAssociation(llvm::tdl::Directive Dir) {435// IMPL-NEXT: switch (Dir) {436// IMPL-NEXT: case TDLD_dira:437// IMPL-NEXT: return Association::None;438// IMPL-NEXT: } // switch (Dir)439// IMPL-NEXT: llvm_unreachable("Unexpected directive");440// IMPL-NEXT: }441// IMPL-EMPTY:442// IMPL-NEXT: llvm::tdl::Category llvm::tdl::getDirectiveCategory(llvm::tdl::Directive Dir) {443// IMPL-NEXT: switch (Dir) {444// IMPL-NEXT: case TDLD_dira:445// IMPL-NEXT: return Category::Executable;446// IMPL-NEXT: } // switch (Dir)447// IMPL-NEXT: llvm_unreachable("Unexpected directive");448// IMPL-NEXT: }449// IMPL-EMPTY:450// IMPL-NEXT: llvm::tdl::SourceLanguage llvm::tdl::getDirectiveLanguages(llvm::tdl::Directive D) {451// IMPL-NEXT: switch (D) {452// IMPL-NEXT: case TDLD_dira:453// IMPL-NEXT: return SourceLanguage::C | SourceLanguage::Fortran;454// IMPL-NEXT: } // switch(D)455// IMPL-NEXT: llvm_unreachable("Unexpected directive");456// IMPL-NEXT: }457// IMPL-EMPTY:458// IMPL-NEXT: static_assert(sizeof(llvm::tdl::Directive) == sizeof(int));459// IMPL-NEXT: {{.*}} static const llvm::tdl::Directive LeafConstructTable[][2] = {460// IMPL-NEXT: {llvm::tdl::TDLD_dira, static_cast<llvm::tdl::Directive>(0),},461// IMPL-NEXT: };462// IMPL-EMPTY:463// IMPL-NEXT: {{.*}} static auto LeafConstructTableEndDirective = LeafConstructTable + 1;464// IMPL-EMPTY:465// IMPL-NEXT: {{.*}} static const int LeafConstructTableOrdering[] = {466// IMPL-NEXT: 0,467// IMPL-NEXT: };468// IMPL-EMPTY:469// IMPL-NEXT: #endif // GEN_DIRECTIVES_IMPL470