1 //===- DirectiveEmitter.cpp - Directive Language Emitter ------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // DirectiveEmitter uses the descriptions of directives and clauses to construct
10 // common code declarations to be used in Frontends.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/TableGen/DirectiveEmitter.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringSet.h"
18 #include "llvm/TableGen/Error.h"
19 #include "llvm/TableGen/Record.h"
20 #include "llvm/TableGen/TableGenBackend.h"
21 
22 using namespace llvm;
23 
24 namespace {
25 // Simple RAII helper for defining ifdef-undef-endif scopes.
26 class IfDefScope {
27 public:
28   IfDefScope(StringRef Name, raw_ostream &OS) : Name(Name), OS(OS) {
29     OS << "#ifdef " << Name << "\n"
30        << "#undef " << Name << "\n";
31   }
32 
33   ~IfDefScope() { OS << "\n#endif // " << Name << "\n\n"; }
34 
35 private:
36   StringRef Name;
37   raw_ostream &OS;
38 };
39 } // end anonymous namespace
40 
41 namespace llvm {
42 
43 // Generate enum class
44 void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS,
45                        StringRef Enum, StringRef Prefix,
46                        DirectiveLanguage &DirLang) {
47   OS << "\n";
48   OS << "enum class " << Enum << " {\n";
49   for (const auto &R : Records) {
50     BaseRecord Rec{R};
51     OS << "  " << Prefix << Rec.getFormattedName() << ",\n";
52   }
53   OS << "};\n";
54   OS << "\n";
55   OS << "static constexpr std::size_t " << Enum
56      << "_enumSize = " << Records.size() << ";\n";
57 
58   // Make the enum values available in the defined namespace. This allows us to
59   // write something like Enum_X if we have a `using namespace <CppNamespace>`.
60   // At the same time we do not loose the strong type guarantees of the enum
61   // class, that is we cannot pass an unsigned as Directive without an explicit
62   // cast.
63   if (DirLang.hasMakeEnumAvailableInNamespace()) {
64     OS << "\n";
65     for (const auto &R : Records) {
66       BaseRecord Rec{R};
67       OS << "constexpr auto " << Prefix << Rec.getFormattedName() << " = "
68          << "llvm::" << DirLang.getCppNamespace() << "::" << Enum
69          << "::" << Prefix << Rec.getFormattedName() << ";\n";
70     }
71   }
72 }
73 
74 // Generate enums for values that clauses can take.
75 // Also generate function declarations for get<Enum>Name(StringRef Str).
76 void GenerateEnumClauseVal(const std::vector<Record *> &Records,
77                            raw_ostream &OS, DirectiveLanguage &DirLang,
78                            std::string &EnumHelperFuncs) {
79   for (const auto &R : Records) {
80     Clause C{R};
81     const auto &ClauseVals = C.getClauseVals();
82     if (ClauseVals.size() <= 0)
83       continue;
84 
85     const auto &EnumName = C.getEnumName();
86     if (EnumName.size() == 0) {
87       PrintError("enumClauseValue field not set in Clause" +
88                  C.getFormattedName() + ".");
89       return;
90     }
91 
92     OS << "\n";
93     OS << "enum class " << EnumName << " {\n";
94     for (const auto &CV : ClauseVals) {
95       ClauseVal CVal{CV};
96       OS << "  " << CV->getName() << "=" << CVal.getValue() << ",\n";
97     }
98     OS << "};\n";
99 
100     if (DirLang.hasMakeEnumAvailableInNamespace()) {
101       OS << "\n";
102       for (const auto &CV : ClauseVals) {
103         OS << "constexpr auto " << CV->getName() << " = "
104            << "llvm::" << DirLang.getCppNamespace() << "::" << EnumName
105            << "::" << CV->getName() << ";\n";
106       }
107       EnumHelperFuncs += (llvm::Twine(EnumName) + llvm::Twine(" get") +
108                           llvm::Twine(EnumName) + llvm::Twine("(StringRef);\n"))
109                              .str();
110     }
111   }
112 }
113 
114 // Generate the declaration section for the enumeration in the directive
115 // language
116 void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
117 
118   const auto &DirectiveLanguages =
119       Records.getAllDerivedDefinitions("DirectiveLanguage");
120 
121   if (DirectiveLanguages.size() != 1) {
122     PrintError("A single definition of DirectiveLanguage is needed.");
123     return;
124   }
125 
126   DirectiveLanguage DirLang{DirectiveLanguages[0]};
127 
128   OS << "#ifndef LLVM_" << DirLang.getName() << "_INC\n";
129   OS << "#define LLVM_" << DirLang.getName() << "_INC\n";
130 
131   if (DirLang.hasEnableBitmaskEnumInNamespace())
132     OS << "\n#include \"llvm/ADT/BitmaskEnum.h\"\n";
133 
134   OS << "\n";
135   OS << "namespace llvm {\n";
136   OS << "class StringRef;\n";
137 
138   // Open namespaces defined in the directive language
139   llvm::SmallVector<StringRef, 2> Namespaces;
140   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
141   for (auto Ns : Namespaces)
142     OS << "namespace " << Ns << " {\n";
143 
144   if (DirLang.hasEnableBitmaskEnumInNamespace())
145     OS << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
146 
147   // Emit Directive enumeration
148   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
149   GenerateEnumClass(Directives, OS, "Directive", DirLang.getDirectivePrefix(),
150                     DirLang);
151 
152   // Emit Clause enumeration
153   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
154   GenerateEnumClass(Clauses, OS, "Clause", DirLang.getClausePrefix(), DirLang);
155 
156   // Emit ClauseVal enumeration
157   std::string EnumHelperFuncs;
158   GenerateEnumClauseVal(Clauses, OS, DirLang, EnumHelperFuncs);
159 
160   // Generic function signatures
161   OS << "\n";
162   OS << "// Enumeration helper functions\n";
163   OS << "Directive get" << DirLang.getName()
164      << "DirectiveKind(llvm::StringRef Str);\n";
165   OS << "\n";
166   OS << "llvm::StringRef get" << DirLang.getName()
167      << "DirectiveName(Directive D);\n";
168   OS << "\n";
169   OS << "Clause get" << DirLang.getName()
170      << "ClauseKind(llvm::StringRef Str);\n";
171   OS << "\n";
172   OS << "llvm::StringRef get" << DirLang.getName() << "ClauseName(Clause C);\n";
173   OS << "\n";
174   OS << "/// Return true if \\p C is a valid clause for \\p D in version \\p "
175      << "Version.\n";
176   OS << "bool isAllowedClauseForDirective(Directive D, "
177      << "Clause C, unsigned Version);\n";
178   OS << "\n";
179   if (EnumHelperFuncs.length() > 0) {
180     OS << EnumHelperFuncs;
181     OS << "\n";
182   }
183 
184   // Closing namespaces
185   for (auto Ns : llvm::reverse(Namespaces))
186     OS << "} // namespace " << Ns << "\n";
187 
188   OS << "} // namespace llvm\n";
189 
190   OS << "#endif // LLVM_" << DirLang.getName() << "_INC\n";
191 }
192 
193 // Generate function implementation for get<Enum>Name(StringRef Str)
194 void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
195                      StringRef Enum, DirectiveLanguage &DirLang,
196                      StringRef Prefix) {
197   OS << "\n";
198   OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
199      << DirLang.getName() << Enum << "Name(" << Enum << " Kind) {\n";
200   OS << "  switch (Kind) {\n";
201   for (const auto &R : Records) {
202     BaseRecord Rec{R};
203     OS << "    case " << Prefix << Rec.getFormattedName() << ":\n";
204     OS << "      return \"";
205     if (Rec.getAlternativeName().empty())
206       OS << Rec.getName();
207     else
208       OS << Rec.getAlternativeName();
209     OS << "\";\n";
210   }
211   OS << "  }\n"; // switch
212   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " << Enum
213      << " kind\");\n";
214   OS << "}\n";
215 }
216 
217 // Generate function implementation for get<Enum>Kind(StringRef Str)
218 void GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
219                      StringRef Enum, DirectiveLanguage &DirLang,
220                      StringRef Prefix, bool ImplicitAsUnknown) {
221 
222   auto DefaultIt = std::find_if(Records.begin(), Records.end(), [](Record *R) {
223     return R->getValueAsBit("isDefault") == true;
224   });
225 
226   if (DefaultIt == Records.end()) {
227     PrintError("At least one " + Enum + " must be defined as default.");
228     return;
229   }
230 
231   BaseRecord DefaultRec{(*DefaultIt)};
232 
233   OS << "\n";
234   OS << Enum << " llvm::" << DirLang.getCppNamespace() << "::get"
235      << DirLang.getName() << Enum << "Kind(llvm::StringRef Str) {\n";
236   OS << "  return llvm::StringSwitch<" << Enum << ">(Str)\n";
237 
238   for (const auto &R : Records) {
239     BaseRecord Rec{R};
240     if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
241       OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
242          << DefaultRec.getFormattedName() << ")\n";
243     } else {
244       OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
245          << Rec.getFormattedName() << ")\n";
246     }
247   }
248   OS << "    .Default(" << Prefix << DefaultRec.getFormattedName() << ");\n";
249   OS << "}\n";
250 }
251 
252 // Generate function implementation for get<ClauseVal>Kind(StringRef Str)
253 void GenerateGetKindClauseVal(const std::vector<Record *> &Records,
254                               raw_ostream &OS, StringRef Namespace) {
255 
256   for (const auto &R : Records) {
257     Clause C{R};
258     const auto &ClauseVals = C.getClauseVals();
259     if (ClauseVals.size() <= 0)
260       continue;
261 
262     auto DefaultIt =
263         std::find_if(ClauseVals.begin(), ClauseVals.end(), [](Record *CV) {
264           return CV->getValueAsBit("isDefault") == true;
265         });
266 
267     if (DefaultIt == ClauseVals.end()) {
268       PrintError("At least one val in Clause " + C.getFormattedName() +
269                  " must be defined as default.");
270       return;
271     }
272     const auto DefaultName = (*DefaultIt)->getName();
273 
274     const auto &EnumName = C.getEnumName();
275     if (EnumName.size() == 0) {
276       PrintError("enumClauseValue field not set in Clause" +
277                  C.getFormattedName() + ".");
278       return;
279     }
280 
281     OS << "\n";
282     OS << EnumName << " llvm::" << Namespace << "::get" << EnumName
283        << "(llvm::StringRef Str) {\n";
284     OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n";
285     for (const auto &CV : ClauseVals) {
286       ClauseVal CVal{CV};
287       OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName()
288          << ")\n";
289     }
290     OS << "    .Default(" << DefaultName << ");\n";
291     OS << "}\n";
292   }
293 }
294 
295 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
296                                      raw_ostream &OS, StringRef DirectiveName,
297                                      DirectiveLanguage &DirLang,
298                                      llvm::StringSet<> &Cases) {
299   for (const auto &C : Clauses) {
300     VersionedClause VerClause{C};
301 
302     const auto ClauseFormattedName = VerClause.getClause().getFormattedName();
303 
304     if (Cases.find(ClauseFormattedName) == Cases.end()) {
305       Cases.insert(ClauseFormattedName);
306       OS << "        case " << DirLang.getClausePrefix() << ClauseFormattedName
307          << ":\n";
308       OS << "          return " << VerClause.getMinVersion()
309          << " <= Version && " << VerClause.getMaxVersion() << " >= Version;\n";
310     }
311   }
312 }
313 
314 // Generate the isAllowedClauseForDirective function implementation.
315 void GenerateIsAllowedClause(const std::vector<Record *> &Directives,
316                              raw_ostream &OS, DirectiveLanguage &DirLang) {
317   OS << "\n";
318   OS << "bool llvm::" << DirLang.getCppNamespace()
319      << "::isAllowedClauseForDirective("
320      << "Directive D, Clause C, unsigned Version) {\n";
321   OS << "  assert(unsigned(D) <= llvm::" << DirLang.getCppNamespace()
322      << "::Directive_enumSize);\n";
323   OS << "  assert(unsigned(C) <= llvm::" << DirLang.getCppNamespace()
324      << "::Clause_enumSize);\n";
325 
326   OS << "  switch (D) {\n";
327 
328   for (const auto &D : Directives) {
329     Directive Dir{D};
330 
331     OS << "    case " << DirLang.getDirectivePrefix() << Dir.getFormattedName()
332        << ":\n";
333     if (Dir.getAllowedClauses().size() == 0 &&
334         Dir.getAllowedOnceClauses().size() == 0 &&
335         Dir.getAllowedExclusiveClauses().size() == 0 &&
336         Dir.getRequiredClauses().size() == 0) {
337       OS << "      return false;\n";
338     } else {
339       OS << "      switch (C) {\n";
340 
341       llvm::StringSet<> Cases;
342 
343       GenerateCaseForVersionedClauses(Dir.getAllowedClauses(), OS,
344                                       Dir.getName(), DirLang, Cases);
345 
346       GenerateCaseForVersionedClauses(Dir.getAllowedOnceClauses(), OS,
347                                       Dir.getName(), DirLang, Cases);
348 
349       GenerateCaseForVersionedClauses(Dir.getAllowedExclusiveClauses(), OS,
350                                       Dir.getName(), DirLang, Cases);
351 
352       GenerateCaseForVersionedClauses(Dir.getRequiredClauses(), OS,
353                                       Dir.getName(), DirLang, Cases);
354 
355       OS << "        default:\n";
356       OS << "          return false;\n";
357       OS << "      }\n"; // End of clauses switch
358     }
359     OS << "      break;\n";
360   }
361 
362   OS << "  }\n"; // End of directives switch
363   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName()
364      << " Directive kind\");\n";
365   OS << "}\n"; // End of function isAllowedClauseForDirective
366 }
367 
368 // Generate a simple enum set with the give clauses.
369 void GenerateClauseSet(const std::vector<Record *> &Clauses, raw_ostream &OS,
370                        StringRef ClauseSetPrefix, Directive &Dir,
371                        DirectiveLanguage &DirLang) {
372 
373   OS << "\n";
374   OS << "  static " << DirLang.getClauseEnumSetClass() << " " << ClauseSetPrefix
375      << DirLang.getDirectivePrefix() << Dir.getFormattedName() << " {\n";
376 
377   for (const auto &C : Clauses) {
378     VersionedClause VerClause{C};
379     OS << "    llvm::" << DirLang.getCppNamespace()
380        << "::Clause::" << DirLang.getClausePrefix()
381        << VerClause.getClause().getFormattedName() << ",\n";
382   }
383   OS << "  };\n";
384 }
385 
386 // Generate an enum set for the 4 kinds of clauses linked to a directive.
387 void GenerateDirectiveClauseSets(const std::vector<Record *> &Directives,
388                                  raw_ostream &OS, DirectiveLanguage &DirLang) {
389 
390   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_SETS", OS);
391 
392   OS << "\n";
393   OS << "namespace llvm {\n";
394 
395   // Open namespaces defined in the directive language.
396   llvm::SmallVector<StringRef, 2> Namespaces;
397   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
398   for (auto Ns : Namespaces)
399     OS << "namespace " << Ns << " {\n";
400 
401   for (const auto &D : Directives) {
402     Directive Dir{D};
403 
404     OS << "\n";
405     OS << "  // Sets for " << Dir.getName() << "\n";
406 
407     GenerateClauseSet(Dir.getAllowedClauses(), OS, "allowedClauses_", Dir,
408                       DirLang);
409     GenerateClauseSet(Dir.getAllowedOnceClauses(), OS, "allowedOnceClauses_",
410                       Dir, DirLang);
411     GenerateClauseSet(Dir.getAllowedExclusiveClauses(), OS,
412                       "allowedExclusiveClauses_", Dir, DirLang);
413     GenerateClauseSet(Dir.getRequiredClauses(), OS, "requiredClauses_", Dir,
414                       DirLang);
415   }
416 
417   // Closing namespaces
418   for (auto Ns : llvm::reverse(Namespaces))
419     OS << "} // namespace " << Ns << "\n";
420 
421   OS << "} // namespace llvm\n";
422 }
423 
424 // Generate a map of directive (key) with DirectiveClauses struct as values.
425 // The struct holds the 4 sets of enumeration for the 4 kinds of clauses
426 // allowances (allowed, allowed once, allowed exclusive and required).
427 void GenerateDirectiveClauseMap(const std::vector<Record *> &Directives,
428                                 raw_ostream &OS, DirectiveLanguage &DirLang) {
429 
430   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_MAP", OS);
431 
432   OS << "\n";
433   OS << "{\n";
434 
435   for (const auto &D : Directives) {
436     Directive Dir{D};
437     OS << "  {llvm::" << DirLang.getCppNamespace()
438        << "::Directive::" << DirLang.getDirectivePrefix()
439        << Dir.getFormattedName() << ",\n";
440     OS << "    {\n";
441     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_"
442        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
443     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_"
444        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
445     OS << "      llvm::" << DirLang.getCppNamespace()
446        << "::allowedExclusiveClauses_" << DirLang.getDirectivePrefix()
447        << Dir.getFormattedName() << ",\n";
448     OS << "      llvm::" << DirLang.getCppNamespace() << "::requiredClauses_"
449        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
450     OS << "    }\n";
451     OS << "  },\n";
452   }
453 
454   OS << "}\n";
455 }
456 
457 // Generate classes entry for Flang clauses in the Flang parse-tree
458 // If the clause as a non-generic class, no entry is generated.
459 // If the clause does not hold a value, an EMPTY_CLASS is used.
460 // If the clause class is generic then a WRAPPER_CLASS is used. When the value
461 // is optional, the value class is wrapped into a std::optional.
462 void GenerateFlangClauseParserClass(const std::vector<Record *> &Clauses,
463                                     raw_ostream &OS) {
464 
465   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS);
466 
467   OS << "\n";
468 
469   for (const auto &C : Clauses) {
470     Clause Clause{C};
471     // Clause has a non generic class.
472     if (!Clause.getFlangClass().empty())
473       continue;
474     if (!Clause.getFlangClassValue().empty()) {
475       OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
476       if (Clause.isValueOptional() && Clause.isValueList()) {
477         OS << "std::optional<std::list<" << Clause.getFlangClassValue()
478            << ">>";
479       } else if (Clause.isValueOptional()) {
480         OS << "std::optional<" << Clause.getFlangClassValue() << ">";
481       } else if (Clause.isValueList()) {
482         OS << "std::list<" << Clause.getFlangClassValue() << ">";
483       } else {
484         OS << Clause.getFlangClassValue();
485       }
486     } else {
487       OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
488     }
489     OS << ");\n";
490   }
491 }
492 
493 // Generate a list of the different clause classes for Flang.
494 void GenerateFlangClauseParserClassList(const std::vector<Record *> &Clauses,
495                                         raw_ostream &OS) {
496 
497   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
498 
499   OS << "\n";
500   llvm::interleaveComma(Clauses, OS, [&](Record *C) {
501     Clause Clause{C};
502     if (Clause.getFlangClass().empty())
503       OS << Clause.getFormattedParserClassName() << "\n";
504     else
505       OS << Clause.getFlangClass() << "\n";
506   });
507 }
508 
509 // Generate dump node list for the clauses holding a generic class name.
510 void GenerateFlangClauseDump(const std::vector<Record *> &Clauses,
511                              const DirectiveLanguage &DirLang,
512                              raw_ostream &OS) {
513 
514   IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS);
515 
516   OS << "\n";
517   for (const auto &C : Clauses) {
518     Clause Clause{C};
519     // Clause has a non generic class.
520     if (!Clause.getFlangClass().empty())
521       continue;
522 
523     OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", "
524        << Clause.getFormattedParserClassName() << ")\n";
525   }
526 }
527 
528 // Generate Unparse functions for clauses classes in the Flang parse-tree
529 // If the clause is a non-generic class, no entry is generated.
530 void GenerateFlangClauseUnparse(const std::vector<Record *> &Clauses,
531                                 const DirectiveLanguage &DirLang,
532                                 raw_ostream &OS) {
533 
534   IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
535 
536   OS << "\n";
537 
538   for (const auto &C : Clauses) {
539     Clause Clause{C};
540     // Clause has a non generic class.
541     if (!Clause.getFlangClass().empty())
542       continue;
543     if (!Clause.getFlangClassValue().empty()) {
544       if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) {
545         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
546            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
547         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
548 
549         OS << "  Walk(\"(\", x.v, \")\");\n";
550         OS << "}\n";
551       } else if (Clause.isValueOptional()) {
552         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
553            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
554         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
555         OS << "  Put(\"(\");\n";
556         OS << "  if (x.v.has_value())\n";
557         if (Clause.isValueList())
558           OS << "    Walk(x.v, \",\");\n";
559         else
560           OS << "    Walk(x.v);\n";
561         OS << "  else\n";
562         OS << "    Put(\"" << Clause.getDefaultValue() << "\");\n";
563         OS << "  Put(\")\");\n";
564         OS << "}\n";
565       } else {
566         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
567            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
568         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
569         OS << "  Put(\"(\");\n";
570         if (Clause.isValueList())
571           OS << "  Walk(x.v, \",\");\n";
572         else
573           OS << "  Walk(x.v);\n";
574         OS << "  Put(\")\");\n";
575         OS << "}\n";
576       }
577     } else {
578       OS << "void Before(const " << DirLang.getFlangClauseBaseClass()
579          << "::" << Clause.getFormattedParserClassName() << " &) { Word(\""
580          << Clause.getName().upper() << "\"); }\n";
581     }
582   }
583 }
584 
585 // Generate the implemenation section for the enumeration in the directive
586 // language
587 void EmitDirectivesFlangImpl(const std::vector<Record *> &Directives,
588                              const std::vector<Record *> &Clauses,
589                              raw_ostream &OS,
590                              DirectiveLanguage &DirectiveLanguage) {
591 
592   GenerateDirectiveClauseSets(Directives, OS, DirectiveLanguage);
593 
594   GenerateDirectiveClauseMap(Directives, OS, DirectiveLanguage);
595 
596   GenerateFlangClauseParserClass(Clauses, OS);
597 
598   GenerateFlangClauseParserClassList(Clauses, OS);
599 
600   GenerateFlangClauseDump(Clauses, DirectiveLanguage, OS);
601 
602   GenerateFlangClauseUnparse(Clauses, DirectiveLanguage, OS);
603 }
604 
605 // Generate the implemenation section for the enumeration in the directive
606 // language.
607 void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
608 
609   const auto &DirectiveLanguages =
610       Records.getAllDerivedDefinitions("DirectiveLanguage");
611 
612   if (DirectiveLanguages.size() != 1) {
613     PrintError("A single definition of DirectiveLanguage is needed.");
614     return;
615   }
616 
617   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
618   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
619   DirectiveLanguage DirectiveLanguage{DirectiveLanguages[0]};
620   EmitDirectivesFlangImpl(Directives, Clauses, OS, DirectiveLanguage);
621 }
622 
623 // Generate the implemenation for the enumeration in the directive
624 // language. This code can be included in library.
625 void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
626 
627   const auto &DirectiveLanguages =
628       Records.getAllDerivedDefinitions("DirectiveLanguage");
629 
630   if (DirectiveLanguages.size() != 1) {
631     PrintError("A single definition of DirectiveLanguage is needed.");
632     return;
633   }
634 
635   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
636 
637   DirectiveLanguage DirLang = DirectiveLanguage{DirectiveLanguages[0]};
638 
639   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
640 
641   if (!DirLang.getIncludeHeader().empty())
642     OS << "#include \"" << DirLang.getIncludeHeader() << "\"\n\n";
643 
644   OS << "#include \"llvm/ADT/StringRef.h\"\n";
645   OS << "#include \"llvm/ADT/StringSwitch.h\"\n";
646   OS << "#include \"llvm/Support/ErrorHandling.h\"\n";
647   OS << "\n";
648   OS << "using namespace llvm;\n";
649   llvm::SmallVector<StringRef, 2> Namespaces;
650   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
651   for (auto Ns : Namespaces)
652     OS << "using namespace " << Ns << ";\n";
653 
654   // getDirectiveKind(StringRef Str)
655   GenerateGetKind(Directives, OS, "Directive", DirLang,
656                   DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false);
657 
658   // getDirectiveName(Directive Kind)
659   GenerateGetName(Directives, OS, "Directive", DirLang,
660                   DirLang.getDirectivePrefix());
661 
662   // getClauseKind(StringRef Str)
663   GenerateGetKind(Clauses, OS, "Clause", DirLang, DirLang.getClausePrefix(),
664                   /*ImplicitAsUnknown=*/true);
665 
666   // getClauseName(Clause Kind)
667   GenerateGetName(Clauses, OS, "Clause", DirLang, DirLang.getClausePrefix());
668 
669   // get<ClauseVal>Kind(StringRef Str)
670   GenerateGetKindClauseVal(Clauses, OS, DirLang.getCppNamespace());
671 
672   // isAllowedClauseForDirective(Directive D, Clause C, unsigned Version)
673   GenerateIsAllowedClause(Directives, OS, DirLang);
674 }
675 
676 } // namespace llvm
677