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 bool HasDuplicateClauses(const std::vector<Record *> &Clauses,
115                          const Directive &Directive,
116                          llvm::StringSet<> &CrtClauses) {
117   bool hasError = false;
118   for (const auto &C : Clauses) {
119     VersionedClause VerClause{C};
120     const auto insRes = CrtClauses.insert(VerClause.getClause().getName());
121     if (!insRes.second) {
122       PrintError("Clause " + VerClause.getClause().getRecordName() +
123                  " already defined on directive " + Directive.getRecordName());
124       hasError = true;
125     }
126   }
127   return hasError;
128 }
129 
130 bool HasDuplicateClausesInDirectives(const std::vector<Record *> &Directives) {
131   for (const auto &D : Directives) {
132     Directive Dir{D};
133     llvm::StringSet<> Clauses;
134     if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) ||
135         HasDuplicateClauses(Dir.getAllowedOnceClauses(), Dir, Clauses) ||
136         HasDuplicateClauses(Dir.getAllowedExclusiveClauses(), Dir, Clauses) ||
137         HasDuplicateClauses(Dir.getRequiredClauses(), Dir, Clauses)) {
138       PrintFatalError(
139           "One or more clauses are defined multiple times on directive " +
140           Dir.getRecordName());
141       return true;
142     }
143   }
144   return false;
145 }
146 
147 // Check consitency of records. Return true if an error has been detected.
148 // Return false if the records are valid.
149 bool CheckRecordsValidity(RecordKeeper &Records) {
150   const auto &DirectiveLanguages =
151       Records.getAllDerivedDefinitions("DirectiveLanguage");
152 
153   if (DirectiveLanguages.size() != 1) {
154     PrintError("A single definition of DirectiveLanguage is needed.");
155     return true;
156   }
157 
158   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
159   return HasDuplicateClausesInDirectives(Directives);
160 }
161 
162 // Generate the declaration section for the enumeration in the directive
163 // language
164 void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
165 
166   if (CheckRecordsValidity(Records))
167     return;
168 
169   const auto &DirectiveLanguages =
170       Records.getAllDerivedDefinitions("DirectiveLanguage");
171 
172   DirectiveLanguage DirLang{DirectiveLanguages[0]};
173   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
174 
175   OS << "#ifndef LLVM_" << DirLang.getName() << "_INC\n";
176   OS << "#define LLVM_" << DirLang.getName() << "_INC\n";
177 
178   if (DirLang.hasEnableBitmaskEnumInNamespace())
179     OS << "\n#include \"llvm/ADT/BitmaskEnum.h\"\n";
180 
181   OS << "\n";
182   OS << "namespace llvm {\n";
183   OS << "class StringRef;\n";
184 
185   // Open namespaces defined in the directive language
186   llvm::SmallVector<StringRef, 2> Namespaces;
187   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
188   for (auto Ns : Namespaces)
189     OS << "namespace " << Ns << " {\n";
190 
191   if (DirLang.hasEnableBitmaskEnumInNamespace())
192     OS << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
193 
194   // Emit Directive enumeration
195   GenerateEnumClass(Directives, OS, "Directive", DirLang.getDirectivePrefix(),
196                     DirLang);
197 
198   // Emit Clause enumeration
199   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
200   GenerateEnumClass(Clauses, OS, "Clause", DirLang.getClausePrefix(), DirLang);
201 
202   // Emit ClauseVal enumeration
203   std::string EnumHelperFuncs;
204   GenerateEnumClauseVal(Clauses, OS, DirLang, EnumHelperFuncs);
205 
206   // Generic function signatures
207   OS << "\n";
208   OS << "// Enumeration helper functions\n";
209   OS << "Directive get" << DirLang.getName()
210      << "DirectiveKind(llvm::StringRef Str);\n";
211   OS << "\n";
212   OS << "llvm::StringRef get" << DirLang.getName()
213      << "DirectiveName(Directive D);\n";
214   OS << "\n";
215   OS << "Clause get" << DirLang.getName()
216      << "ClauseKind(llvm::StringRef Str);\n";
217   OS << "\n";
218   OS << "llvm::StringRef get" << DirLang.getName() << "ClauseName(Clause C);\n";
219   OS << "\n";
220   OS << "/// Return true if \\p C is a valid clause for \\p D in version \\p "
221      << "Version.\n";
222   OS << "bool isAllowedClauseForDirective(Directive D, "
223      << "Clause C, unsigned Version);\n";
224   OS << "\n";
225   if (EnumHelperFuncs.length() > 0) {
226     OS << EnumHelperFuncs;
227     OS << "\n";
228   }
229 
230   // Closing namespaces
231   for (auto Ns : llvm::reverse(Namespaces))
232     OS << "} // namespace " << Ns << "\n";
233 
234   OS << "} // namespace llvm\n";
235 
236   OS << "#endif // LLVM_" << DirLang.getName() << "_INC\n";
237 }
238 
239 // Generate function implementation for get<Enum>Name(StringRef Str)
240 void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
241                      StringRef Enum, DirectiveLanguage &DirLang,
242                      StringRef Prefix) {
243   OS << "\n";
244   OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
245      << DirLang.getName() << Enum << "Name(" << Enum << " Kind) {\n";
246   OS << "  switch (Kind) {\n";
247   for (const auto &R : Records) {
248     BaseRecord Rec{R};
249     OS << "    case " << Prefix << Rec.getFormattedName() << ":\n";
250     OS << "      return \"";
251     if (Rec.getAlternativeName().empty())
252       OS << Rec.getName();
253     else
254       OS << Rec.getAlternativeName();
255     OS << "\";\n";
256   }
257   OS << "  }\n"; // switch
258   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " << Enum
259      << " kind\");\n";
260   OS << "}\n";
261 }
262 
263 // Generate function implementation for get<Enum>Kind(StringRef Str)
264 void GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
265                      StringRef Enum, DirectiveLanguage &DirLang,
266                      StringRef Prefix, bool ImplicitAsUnknown) {
267 
268   auto DefaultIt = std::find_if(Records.begin(), Records.end(), [](Record *R) {
269     return R->getValueAsBit("isDefault") == true;
270   });
271 
272   if (DefaultIt == Records.end()) {
273     PrintError("At least one " + Enum + " must be defined as default.");
274     return;
275   }
276 
277   BaseRecord DefaultRec{(*DefaultIt)};
278 
279   OS << "\n";
280   OS << Enum << " llvm::" << DirLang.getCppNamespace() << "::get"
281      << DirLang.getName() << Enum << "Kind(llvm::StringRef Str) {\n";
282   OS << "  return llvm::StringSwitch<" << Enum << ">(Str)\n";
283 
284   for (const auto &R : Records) {
285     BaseRecord Rec{R};
286     if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
287       OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
288          << DefaultRec.getFormattedName() << ")\n";
289     } else {
290       OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
291          << Rec.getFormattedName() << ")\n";
292     }
293   }
294   OS << "    .Default(" << Prefix << DefaultRec.getFormattedName() << ");\n";
295   OS << "}\n";
296 }
297 
298 // Generate function implementation for get<ClauseVal>Kind(StringRef Str)
299 void GenerateGetKindClauseVal(const std::vector<Record *> &Records,
300                               raw_ostream &OS, StringRef Namespace) {
301 
302   for (const auto &R : Records) {
303     Clause C{R};
304     const auto &ClauseVals = C.getClauseVals();
305     if (ClauseVals.size() <= 0)
306       continue;
307 
308     auto DefaultIt =
309         std::find_if(ClauseVals.begin(), ClauseVals.end(), [](Record *CV) {
310           return CV->getValueAsBit("isDefault") == true;
311         });
312 
313     if (DefaultIt == ClauseVals.end()) {
314       PrintError("At least one val in Clause " + C.getFormattedName() +
315                  " must be defined as default.");
316       return;
317     }
318     const auto DefaultName = (*DefaultIt)->getName();
319 
320     const auto &EnumName = C.getEnumName();
321     if (EnumName.size() == 0) {
322       PrintError("enumClauseValue field not set in Clause" +
323                  C.getFormattedName() + ".");
324       return;
325     }
326 
327     OS << "\n";
328     OS << EnumName << " llvm::" << Namespace << "::get" << EnumName
329        << "(llvm::StringRef Str) {\n";
330     OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n";
331     for (const auto &CV : ClauseVals) {
332       ClauseVal CVal{CV};
333       OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName()
334          << ")\n";
335     }
336     OS << "    .Default(" << DefaultName << ");\n";
337     OS << "}\n";
338   }
339 }
340 
341 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
342                                      raw_ostream &OS, StringRef DirectiveName,
343                                      DirectiveLanguage &DirLang,
344                                      llvm::StringSet<> &Cases) {
345   for (const auto &C : Clauses) {
346     VersionedClause VerClause{C};
347 
348     const auto ClauseFormattedName = VerClause.getClause().getFormattedName();
349 
350     if (Cases.find(ClauseFormattedName) == Cases.end()) {
351       Cases.insert(ClauseFormattedName);
352       OS << "        case " << DirLang.getClausePrefix() << ClauseFormattedName
353          << ":\n";
354       OS << "          return " << VerClause.getMinVersion()
355          << " <= Version && " << VerClause.getMaxVersion() << " >= Version;\n";
356     }
357   }
358 }
359 
360 // Generate the isAllowedClauseForDirective function implementation.
361 void GenerateIsAllowedClause(const std::vector<Record *> &Directives,
362                              raw_ostream &OS, DirectiveLanguage &DirLang) {
363   OS << "\n";
364   OS << "bool llvm::" << DirLang.getCppNamespace()
365      << "::isAllowedClauseForDirective("
366      << "Directive D, Clause C, unsigned Version) {\n";
367   OS << "  assert(unsigned(D) <= llvm::" << DirLang.getCppNamespace()
368      << "::Directive_enumSize);\n";
369   OS << "  assert(unsigned(C) <= llvm::" << DirLang.getCppNamespace()
370      << "::Clause_enumSize);\n";
371 
372   OS << "  switch (D) {\n";
373 
374   for (const auto &D : Directives) {
375     Directive Dir{D};
376 
377     OS << "    case " << DirLang.getDirectivePrefix() << Dir.getFormattedName()
378        << ":\n";
379     if (Dir.getAllowedClauses().size() == 0 &&
380         Dir.getAllowedOnceClauses().size() == 0 &&
381         Dir.getAllowedExclusiveClauses().size() == 0 &&
382         Dir.getRequiredClauses().size() == 0) {
383       OS << "      return false;\n";
384     } else {
385       OS << "      switch (C) {\n";
386 
387       llvm::StringSet<> Cases;
388 
389       GenerateCaseForVersionedClauses(Dir.getAllowedClauses(), OS,
390                                       Dir.getName(), DirLang, Cases);
391 
392       GenerateCaseForVersionedClauses(Dir.getAllowedOnceClauses(), OS,
393                                       Dir.getName(), DirLang, Cases);
394 
395       GenerateCaseForVersionedClauses(Dir.getAllowedExclusiveClauses(), OS,
396                                       Dir.getName(), DirLang, Cases);
397 
398       GenerateCaseForVersionedClauses(Dir.getRequiredClauses(), OS,
399                                       Dir.getName(), DirLang, Cases);
400 
401       OS << "        default:\n";
402       OS << "          return false;\n";
403       OS << "      }\n"; // End of clauses switch
404     }
405     OS << "      break;\n";
406   }
407 
408   OS << "  }\n"; // End of directives switch
409   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName()
410      << " Directive kind\");\n";
411   OS << "}\n"; // End of function isAllowedClauseForDirective
412 }
413 
414 // Generate a simple enum set with the give clauses.
415 void GenerateClauseSet(const std::vector<Record *> &Clauses, raw_ostream &OS,
416                        StringRef ClauseSetPrefix, Directive &Dir,
417                        DirectiveLanguage &DirLang) {
418 
419   OS << "\n";
420   OS << "  static " << DirLang.getClauseEnumSetClass() << " " << ClauseSetPrefix
421      << DirLang.getDirectivePrefix() << Dir.getFormattedName() << " {\n";
422 
423   for (const auto &C : Clauses) {
424     VersionedClause VerClause{C};
425     OS << "    llvm::" << DirLang.getCppNamespace()
426        << "::Clause::" << DirLang.getClausePrefix()
427        << VerClause.getClause().getFormattedName() << ",\n";
428   }
429   OS << "  };\n";
430 }
431 
432 // Generate an enum set for the 4 kinds of clauses linked to a directive.
433 void GenerateDirectiveClauseSets(const std::vector<Record *> &Directives,
434                                  raw_ostream &OS, DirectiveLanguage &DirLang) {
435 
436   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_SETS", OS);
437 
438   OS << "\n";
439   OS << "namespace llvm {\n";
440 
441   // Open namespaces defined in the directive language.
442   llvm::SmallVector<StringRef, 2> Namespaces;
443   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
444   for (auto Ns : Namespaces)
445     OS << "namespace " << Ns << " {\n";
446 
447   for (const auto &D : Directives) {
448     Directive Dir{D};
449 
450     OS << "\n";
451     OS << "  // Sets for " << Dir.getName() << "\n";
452 
453     GenerateClauseSet(Dir.getAllowedClauses(), OS, "allowedClauses_", Dir,
454                       DirLang);
455     GenerateClauseSet(Dir.getAllowedOnceClauses(), OS, "allowedOnceClauses_",
456                       Dir, DirLang);
457     GenerateClauseSet(Dir.getAllowedExclusiveClauses(), OS,
458                       "allowedExclusiveClauses_", Dir, DirLang);
459     GenerateClauseSet(Dir.getRequiredClauses(), OS, "requiredClauses_", Dir,
460                       DirLang);
461   }
462 
463   // Closing namespaces
464   for (auto Ns : llvm::reverse(Namespaces))
465     OS << "} // namespace " << Ns << "\n";
466 
467   OS << "} // namespace llvm\n";
468 }
469 
470 // Generate a map of directive (key) with DirectiveClauses struct as values.
471 // The struct holds the 4 sets of enumeration for the 4 kinds of clauses
472 // allowances (allowed, allowed once, allowed exclusive and required).
473 void GenerateDirectiveClauseMap(const std::vector<Record *> &Directives,
474                                 raw_ostream &OS, DirectiveLanguage &DirLang) {
475 
476   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_MAP", OS);
477 
478   OS << "\n";
479   OS << "{\n";
480 
481   for (const auto &D : Directives) {
482     Directive Dir{D};
483     OS << "  {llvm::" << DirLang.getCppNamespace()
484        << "::Directive::" << DirLang.getDirectivePrefix()
485        << Dir.getFormattedName() << ",\n";
486     OS << "    {\n";
487     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_"
488        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
489     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_"
490        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
491     OS << "      llvm::" << DirLang.getCppNamespace()
492        << "::allowedExclusiveClauses_" << DirLang.getDirectivePrefix()
493        << Dir.getFormattedName() << ",\n";
494     OS << "      llvm::" << DirLang.getCppNamespace() << "::requiredClauses_"
495        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
496     OS << "    }\n";
497     OS << "  },\n";
498   }
499 
500   OS << "}\n";
501 }
502 
503 // Generate classes entry for Flang clauses in the Flang parse-tree
504 // If the clause as a non-generic class, no entry is generated.
505 // If the clause does not hold a value, an EMPTY_CLASS is used.
506 // If the clause class is generic then a WRAPPER_CLASS is used. When the value
507 // is optional, the value class is wrapped into a std::optional.
508 void GenerateFlangClauseParserClass(const std::vector<Record *> &Clauses,
509                                     raw_ostream &OS) {
510 
511   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS);
512 
513   OS << "\n";
514 
515   for (const auto &C : Clauses) {
516     Clause Clause{C};
517     // Clause has a non generic class.
518     if (!Clause.getFlangClass().empty())
519       continue;
520     if (!Clause.getFlangClassValue().empty()) {
521       OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
522       if (Clause.isValueOptional() && Clause.isValueList()) {
523         OS << "std::optional<std::list<" << Clause.getFlangClassValue()
524            << ">>";
525       } else if (Clause.isValueOptional()) {
526         OS << "std::optional<" << Clause.getFlangClassValue() << ">";
527       } else if (Clause.isValueList()) {
528         OS << "std::list<" << Clause.getFlangClassValue() << ">";
529       } else {
530         OS << Clause.getFlangClassValue();
531       }
532     } else {
533       OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
534     }
535     OS << ");\n";
536   }
537 }
538 
539 // Generate a list of the different clause classes for Flang.
540 void GenerateFlangClauseParserClassList(const std::vector<Record *> &Clauses,
541                                         raw_ostream &OS) {
542 
543   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
544 
545   OS << "\n";
546   llvm::interleaveComma(Clauses, OS, [&](Record *C) {
547     Clause Clause{C};
548     if (Clause.getFlangClass().empty())
549       OS << Clause.getFormattedParserClassName() << "\n";
550     else
551       OS << Clause.getFlangClass() << "\n";
552   });
553 }
554 
555 // Generate dump node list for the clauses holding a generic class name.
556 void GenerateFlangClauseDump(const std::vector<Record *> &Clauses,
557                              const DirectiveLanguage &DirLang,
558                              raw_ostream &OS) {
559 
560   IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS);
561 
562   OS << "\n";
563   for (const auto &C : Clauses) {
564     Clause Clause{C};
565     // Clause has a non generic class.
566     if (!Clause.getFlangClass().empty())
567       continue;
568 
569     OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", "
570        << Clause.getFormattedParserClassName() << ")\n";
571   }
572 }
573 
574 // Generate Unparse functions for clauses classes in the Flang parse-tree
575 // If the clause is a non-generic class, no entry is generated.
576 void GenerateFlangClauseUnparse(const std::vector<Record *> &Clauses,
577                                 const DirectiveLanguage &DirLang,
578                                 raw_ostream &OS) {
579 
580   IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
581 
582   OS << "\n";
583 
584   for (const auto &C : Clauses) {
585     Clause Clause{C};
586     // Clause has a non generic class.
587     if (!Clause.getFlangClass().empty())
588       continue;
589     if (!Clause.getFlangClassValue().empty()) {
590       if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) {
591         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
592            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
593         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
594 
595         OS << "  Walk(\"(\", x.v, \")\");\n";
596         OS << "}\n";
597       } else if (Clause.isValueOptional()) {
598         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
599            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
600         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
601         OS << "  Put(\"(\");\n";
602         OS << "  if (x.v.has_value())\n";
603         if (Clause.isValueList())
604           OS << "    Walk(x.v, \",\");\n";
605         else
606           OS << "    Walk(x.v);\n";
607         OS << "  else\n";
608         OS << "    Put(\"" << Clause.getDefaultValue() << "\");\n";
609         OS << "  Put(\")\");\n";
610         OS << "}\n";
611       } else {
612         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
613            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
614         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
615         OS << "  Put(\"(\");\n";
616         if (Clause.isValueList())
617           OS << "  Walk(x.v, \",\");\n";
618         else
619           OS << "  Walk(x.v);\n";
620         OS << "  Put(\")\");\n";
621         OS << "}\n";
622       }
623     } else {
624       OS << "void Before(const " << DirLang.getFlangClauseBaseClass()
625          << "::" << Clause.getFormattedParserClassName() << " &) { Word(\""
626          << Clause.getName().upper() << "\"); }\n";
627     }
628   }
629 }
630 
631 // Generate the implemenation section for the enumeration in the directive
632 // language
633 void EmitDirectivesFlangImpl(const std::vector<Record *> &Directives,
634                              const std::vector<Record *> &Clauses,
635                              raw_ostream &OS,
636                              DirectiveLanguage &DirectiveLanguage) {
637 
638   GenerateDirectiveClauseSets(Directives, OS, DirectiveLanguage);
639 
640   GenerateDirectiveClauseMap(Directives, OS, DirectiveLanguage);
641 
642   GenerateFlangClauseParserClass(Clauses, OS);
643 
644   GenerateFlangClauseParserClassList(Clauses, OS);
645 
646   GenerateFlangClauseDump(Clauses, DirectiveLanguage, OS);
647 
648   GenerateFlangClauseUnparse(Clauses, DirectiveLanguage, OS);
649 }
650 
651 // Generate the implemenation section for the enumeration in the directive
652 // language.
653 void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
654   if (CheckRecordsValidity(Records))
655     return;
656 
657   const auto &DirectiveLanguages =
658       Records.getAllDerivedDefinitions("DirectiveLanguage");
659   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
660   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
661   DirectiveLanguage DirectiveLanguage{DirectiveLanguages[0]};
662   EmitDirectivesFlangImpl(Directives, Clauses, OS, DirectiveLanguage);
663 }
664 
665 // Generate the implemenation for the enumeration in the directive
666 // language. This code can be included in library.
667 void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
668   if (CheckRecordsValidity(Records))
669     return;
670 
671   const auto &DirectiveLanguages =
672       Records.getAllDerivedDefinitions("DirectiveLanguage");
673   const auto &Directives = Records.getAllDerivedDefinitions("Directive");
674   DirectiveLanguage DirLang = DirectiveLanguage{DirectiveLanguages[0]};
675 
676   const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
677 
678   if (!DirLang.getIncludeHeader().empty())
679     OS << "#include \"" << DirLang.getIncludeHeader() << "\"\n\n";
680 
681   OS << "#include \"llvm/ADT/StringRef.h\"\n";
682   OS << "#include \"llvm/ADT/StringSwitch.h\"\n";
683   OS << "#include \"llvm/Support/ErrorHandling.h\"\n";
684   OS << "\n";
685   OS << "using namespace llvm;\n";
686   llvm::SmallVector<StringRef, 2> Namespaces;
687   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
688   for (auto Ns : Namespaces)
689     OS << "using namespace " << Ns << ";\n";
690 
691   // getDirectiveKind(StringRef Str)
692   GenerateGetKind(Directives, OS, "Directive", DirLang,
693                   DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false);
694 
695   // getDirectiveName(Directive Kind)
696   GenerateGetName(Directives, OS, "Directive", DirLang,
697                   DirLang.getDirectivePrefix());
698 
699   // getClauseKind(StringRef Str)
700   GenerateGetKind(Clauses, OS, "Clause", DirLang, DirLang.getClausePrefix(),
701                   /*ImplicitAsUnknown=*/true);
702 
703   // getClauseName(Clause Kind)
704   GenerateGetName(Clauses, OS, "Clause", DirLang, DirLang.getClausePrefix());
705 
706   // get<ClauseVal>Kind(StringRef Str)
707   GenerateGetKindClauseVal(Clauses, OS, DirLang.getCppNamespace());
708 
709   // isAllowedClauseForDirective(Directive D, Clause C, unsigned Version)
710   GenerateIsAllowedClause(Directives, OS, DirLang);
711 }
712 
713 } // namespace llvm
714