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/ADT/StringSwitch.h"
19 #include "llvm/TableGen/Error.h"
20 #include "llvm/TableGen/Record.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                        const 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, const 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       EnumHelperFuncs +=
112           (llvm::Twine("llvm::StringRef get") + llvm::Twine(DirLang.getName()) +
113            llvm::Twine(EnumName) + llvm::Twine("Name(") +
114            llvm::Twine(EnumName) + llvm::Twine(");\n"))
115               .str();
116     }
117   }
118 }
119 
120 bool HasDuplicateClauses(const std::vector<Record *> &Clauses,
121                          const Directive &Directive,
122                          llvm::StringSet<> &CrtClauses) {
123   bool HasError = false;
124   for (const auto &C : Clauses) {
125     VersionedClause VerClause{C};
126     const auto insRes = CrtClauses.insert(VerClause.getClause().getName());
127     if (!insRes.second) {
128       PrintError("Clause " + VerClause.getClause().getRecordName() +
129                  " already defined on directive " + Directive.getRecordName());
130       HasError = true;
131     }
132   }
133   return HasError;
134 }
135 
136 // Check for duplicate clauses in lists. Clauses cannot appear twice in the
137 // three allowed list. Also, since required implies allowed, clauses cannot
138 // appear in both the allowedClauses and requiredClauses lists.
139 bool HasDuplicateClausesInDirectives(const std::vector<Record *> &Directives) {
140   bool HasDuplicate = false;
141   for (const auto &D : Directives) {
142     Directive Dir{D};
143     llvm::StringSet<> Clauses;
144     // Check for duplicates in the three allowed lists.
145     if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) ||
146         HasDuplicateClauses(Dir.getAllowedOnceClauses(), Dir, Clauses) ||
147         HasDuplicateClauses(Dir.getAllowedExclusiveClauses(), Dir, Clauses)) {
148       HasDuplicate = true;
149     }
150     // Check for duplicate between allowedClauses and required
151     Clauses.clear();
152     if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) ||
153         HasDuplicateClauses(Dir.getRequiredClauses(), Dir, Clauses)) {
154       HasDuplicate = true;
155     }
156     if (HasDuplicate)
157       PrintFatalError("One or more clauses are defined multiple times on"
158                       " directive " +
159                       Dir.getRecordName());
160   }
161 
162   return HasDuplicate;
163 }
164 
165 // Check consitency of records. Return true if an error has been detected.
166 // Return false if the records are valid.
167 bool DirectiveLanguage::HasValidityErrors() const {
168   if (getDirectiveLanguages().size() != 1) {
169     PrintFatalError("A single definition of DirectiveLanguage is needed.");
170     return true;
171   }
172 
173   return HasDuplicateClausesInDirectives(getDirectives());
174 }
175 
176 // Generate the declaration section for the enumeration in the directive
177 // language
178 void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
179   const auto DirLang = DirectiveLanguage{Records};
180   if (DirLang.HasValidityErrors())
181     return;
182 
183   OS << "#ifndef LLVM_" << DirLang.getName() << "_INC\n";
184   OS << "#define LLVM_" << DirLang.getName() << "_INC\n";
185 
186   if (DirLang.hasEnableBitmaskEnumInNamespace())
187     OS << "\n#include \"llvm/ADT/BitmaskEnum.h\"\n";
188 
189   OS << "\n";
190   OS << "namespace llvm {\n";
191   OS << "class StringRef;\n";
192 
193   // Open namespaces defined in the directive language
194   llvm::SmallVector<StringRef, 2> Namespaces;
195   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
196   for (auto Ns : Namespaces)
197     OS << "namespace " << Ns << " {\n";
198 
199   if (DirLang.hasEnableBitmaskEnumInNamespace())
200     OS << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
201 
202   // Emit Directive enumeration
203   GenerateEnumClass(DirLang.getDirectives(), OS, "Directive",
204                     DirLang.getDirectivePrefix(), DirLang);
205 
206   // Emit Clause enumeration
207   GenerateEnumClass(DirLang.getClauses(), OS, "Clause",
208                     DirLang.getClausePrefix(), DirLang);
209 
210   // Emit ClauseVal enumeration
211   std::string EnumHelperFuncs;
212   GenerateEnumClauseVal(DirLang.getClauses(), OS, DirLang, EnumHelperFuncs);
213 
214   // Generic function signatures
215   OS << "\n";
216   OS << "// Enumeration helper functions\n";
217   OS << "Directive get" << DirLang.getName()
218      << "DirectiveKind(llvm::StringRef Str);\n";
219   OS << "\n";
220   OS << "llvm::StringRef get" << DirLang.getName()
221      << "DirectiveName(Directive D);\n";
222   OS << "\n";
223   OS << "Clause get" << DirLang.getName()
224      << "ClauseKind(llvm::StringRef Str);\n";
225   OS << "\n";
226   OS << "llvm::StringRef get" << DirLang.getName() << "ClauseName(Clause C);\n";
227   OS << "\n";
228   OS << "/// Return true if \\p C is a valid clause for \\p D in version \\p "
229      << "Version.\n";
230   OS << "bool isAllowedClauseForDirective(Directive D, "
231      << "Clause C, unsigned Version);\n";
232   OS << "\n";
233   if (EnumHelperFuncs.length() > 0) {
234     OS << EnumHelperFuncs;
235     OS << "\n";
236   }
237 
238   // Closing namespaces
239   for (auto Ns : llvm::reverse(Namespaces))
240     OS << "} // namespace " << Ns << "\n";
241 
242   OS << "} // namespace llvm\n";
243 
244   OS << "#endif // LLVM_" << DirLang.getName() << "_INC\n";
245 }
246 
247 // Generate function implementation for get<Enum>Name(StringRef Str)
248 void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
249                      StringRef Enum, const DirectiveLanguage &DirLang,
250                      StringRef Prefix) {
251   OS << "\n";
252   OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
253      << DirLang.getName() << Enum << "Name(" << Enum << " Kind) {\n";
254   OS << "  switch (Kind) {\n";
255   for (const auto &R : Records) {
256     BaseRecord Rec{R};
257     OS << "    case " << Prefix << Rec.getFormattedName() << ":\n";
258     OS << "      return \"";
259     if (Rec.getAlternativeName().empty())
260       OS << Rec.getName();
261     else
262       OS << Rec.getAlternativeName();
263     OS << "\";\n";
264   }
265   OS << "  }\n"; // switch
266   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " << Enum
267      << " kind\");\n";
268   OS << "}\n";
269 }
270 
271 // Generate function implementation for get<Enum>Kind(StringRef Str)
272 void GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
273                      StringRef Enum, const DirectiveLanguage &DirLang,
274                      StringRef Prefix, bool ImplicitAsUnknown) {
275 
276   auto DefaultIt = llvm::find_if(
277       Records, [](Record *R) { return R->getValueAsBit("isDefault") == true; });
278 
279   if (DefaultIt == Records.end()) {
280     PrintError("At least one " + Enum + " must be defined as default.");
281     return;
282   }
283 
284   BaseRecord DefaultRec{(*DefaultIt)};
285 
286   OS << "\n";
287   OS << Enum << " llvm::" << DirLang.getCppNamespace() << "::get"
288      << DirLang.getName() << Enum << "Kind(llvm::StringRef Str) {\n";
289   OS << "  return llvm::StringSwitch<" << Enum << ">(Str)\n";
290 
291   for (const auto &R : Records) {
292     BaseRecord Rec{R};
293     if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
294       OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
295          << DefaultRec.getFormattedName() << ")\n";
296     } else {
297       OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
298          << Rec.getFormattedName() << ")\n";
299     }
300   }
301   OS << "    .Default(" << Prefix << DefaultRec.getFormattedName() << ");\n";
302   OS << "}\n";
303 }
304 
305 // Generate function implementation for get<ClauseVal>Kind(StringRef Str)
306 void GenerateGetKindClauseVal(const DirectiveLanguage &DirLang,
307                               raw_ostream &OS) {
308   for (const auto &R : DirLang.getClauses()) {
309     Clause C{R};
310     const auto &ClauseVals = C.getClauseVals();
311     if (ClauseVals.size() <= 0)
312       continue;
313 
314     auto DefaultIt = llvm::find_if(ClauseVals, [](Record *CV) {
315       return CV->getValueAsBit("isDefault") == true;
316     });
317 
318     if (DefaultIt == ClauseVals.end()) {
319       PrintError("At least one val in Clause " + C.getFormattedName() +
320                  " must be defined as default.");
321       return;
322     }
323     const auto DefaultName = (*DefaultIt)->getName();
324 
325     const auto &EnumName = C.getEnumName();
326     if (EnumName.size() == 0) {
327       PrintError("enumClauseValue field not set in Clause" +
328                  C.getFormattedName() + ".");
329       return;
330     }
331 
332     OS << "\n";
333     OS << EnumName << " llvm::" << DirLang.getCppNamespace() << "::get"
334        << EnumName << "(llvm::StringRef Str) {\n";
335     OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n";
336     for (const auto &CV : ClauseVals) {
337       ClauseVal CVal{CV};
338       OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName()
339          << ")\n";
340     }
341     OS << "    .Default(" << DefaultName << ");\n";
342     OS << "}\n";
343 
344     OS << "\n";
345     OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
346        << DirLang.getName() << EnumName
347        << "Name(llvm::" << DirLang.getCppNamespace() << "::" << EnumName
348        << " x) {\n";
349     OS << "  switch (x) {\n";
350     for (const auto &CV : ClauseVals) {
351       ClauseVal CVal{CV};
352       OS << "    case " << CV->getName() << ":\n";
353       OS << "      return \"" << CVal.getFormattedName() << "\";\n";
354     }
355     OS << "  }\n"; // switch
356     OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " "
357        << EnumName << " kind\");\n";
358     OS << "}\n";
359   }
360 }
361 
362 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
363                                      raw_ostream &OS, StringRef DirectiveName,
364                                      const DirectiveLanguage &DirLang,
365                                      llvm::StringSet<> &Cases) {
366   for (const auto &C : Clauses) {
367     VersionedClause VerClause{C};
368 
369     const auto ClauseFormattedName = VerClause.getClause().getFormattedName();
370 
371     if (Cases.insert(ClauseFormattedName).second) {
372       OS << "        case " << DirLang.getClausePrefix() << ClauseFormattedName
373          << ":\n";
374       OS << "          return " << VerClause.getMinVersion()
375          << " <= Version && " << VerClause.getMaxVersion() << " >= Version;\n";
376     }
377   }
378 }
379 
380 // Generate the isAllowedClauseForDirective function implementation.
381 void GenerateIsAllowedClause(const DirectiveLanguage &DirLang,
382                              raw_ostream &OS) {
383   OS << "\n";
384   OS << "bool llvm::" << DirLang.getCppNamespace()
385      << "::isAllowedClauseForDirective("
386      << "Directive D, Clause C, unsigned Version) {\n";
387   OS << "  assert(unsigned(D) <= llvm::" << DirLang.getCppNamespace()
388      << "::Directive_enumSize);\n";
389   OS << "  assert(unsigned(C) <= llvm::" << DirLang.getCppNamespace()
390      << "::Clause_enumSize);\n";
391 
392   OS << "  switch (D) {\n";
393 
394   for (const auto &D : DirLang.getDirectives()) {
395     Directive Dir{D};
396 
397     OS << "    case " << DirLang.getDirectivePrefix() << Dir.getFormattedName()
398        << ":\n";
399     if (Dir.getAllowedClauses().size() == 0 &&
400         Dir.getAllowedOnceClauses().size() == 0 &&
401         Dir.getAllowedExclusiveClauses().size() == 0 &&
402         Dir.getRequiredClauses().size() == 0) {
403       OS << "      return false;\n";
404     } else {
405       OS << "      switch (C) {\n";
406 
407       llvm::StringSet<> Cases;
408 
409       GenerateCaseForVersionedClauses(Dir.getAllowedClauses(), OS,
410                                       Dir.getName(), DirLang, Cases);
411 
412       GenerateCaseForVersionedClauses(Dir.getAllowedOnceClauses(), OS,
413                                       Dir.getName(), DirLang, Cases);
414 
415       GenerateCaseForVersionedClauses(Dir.getAllowedExclusiveClauses(), OS,
416                                       Dir.getName(), DirLang, Cases);
417 
418       GenerateCaseForVersionedClauses(Dir.getRequiredClauses(), OS,
419                                       Dir.getName(), DirLang, Cases);
420 
421       OS << "        default:\n";
422       OS << "          return false;\n";
423       OS << "      }\n"; // End of clauses switch
424     }
425     OS << "      break;\n";
426   }
427 
428   OS << "  }\n"; // End of directives switch
429   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName()
430      << " Directive kind\");\n";
431   OS << "}\n"; // End of function isAllowedClauseForDirective
432 }
433 
434 // Generate a simple enum set with the give clauses.
435 void GenerateClauseSet(const std::vector<Record *> &Clauses, raw_ostream &OS,
436                        StringRef ClauseSetPrefix, Directive &Dir,
437                        const DirectiveLanguage &DirLang) {
438 
439   OS << "\n";
440   OS << "  static " << DirLang.getClauseEnumSetClass() << " " << ClauseSetPrefix
441      << DirLang.getDirectivePrefix() << Dir.getFormattedName() << " {\n";
442 
443   for (const auto &C : Clauses) {
444     VersionedClause VerClause{C};
445     OS << "    llvm::" << DirLang.getCppNamespace()
446        << "::Clause::" << DirLang.getClausePrefix()
447        << VerClause.getClause().getFormattedName() << ",\n";
448   }
449   OS << "  };\n";
450 }
451 
452 // Generate an enum set for the 4 kinds of clauses linked to a directive.
453 void GenerateDirectiveClauseSets(const DirectiveLanguage &DirLang,
454                                  raw_ostream &OS) {
455 
456   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_SETS", OS);
457 
458   OS << "\n";
459   OS << "namespace llvm {\n";
460 
461   // Open namespaces defined in the directive language.
462   llvm::SmallVector<StringRef, 2> Namespaces;
463   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
464   for (auto Ns : Namespaces)
465     OS << "namespace " << Ns << " {\n";
466 
467   for (const auto &D : DirLang.getDirectives()) {
468     Directive Dir{D};
469 
470     OS << "\n";
471     OS << "  // Sets for " << Dir.getName() << "\n";
472 
473     GenerateClauseSet(Dir.getAllowedClauses(), OS, "allowedClauses_", Dir,
474                       DirLang);
475     GenerateClauseSet(Dir.getAllowedOnceClauses(), OS, "allowedOnceClauses_",
476                       Dir, DirLang);
477     GenerateClauseSet(Dir.getAllowedExclusiveClauses(), OS,
478                       "allowedExclusiveClauses_", Dir, DirLang);
479     GenerateClauseSet(Dir.getRequiredClauses(), OS, "requiredClauses_", Dir,
480                       DirLang);
481   }
482 
483   // Closing namespaces
484   for (auto Ns : llvm::reverse(Namespaces))
485     OS << "} // namespace " << Ns << "\n";
486 
487   OS << "} // namespace llvm\n";
488 }
489 
490 // Generate a map of directive (key) with DirectiveClauses struct as values.
491 // The struct holds the 4 sets of enumeration for the 4 kinds of clauses
492 // allowances (allowed, allowed once, allowed exclusive and required).
493 void GenerateDirectiveClauseMap(const DirectiveLanguage &DirLang,
494                                 raw_ostream &OS) {
495 
496   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_MAP", OS);
497 
498   OS << "\n";
499   OS << "{\n";
500 
501   for (const auto &D : DirLang.getDirectives()) {
502     Directive Dir{D};
503     OS << "  {llvm::" << DirLang.getCppNamespace()
504        << "::Directive::" << DirLang.getDirectivePrefix()
505        << Dir.getFormattedName() << ",\n";
506     OS << "    {\n";
507     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_"
508        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
509     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_"
510        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
511     OS << "      llvm::" << DirLang.getCppNamespace()
512        << "::allowedExclusiveClauses_" << DirLang.getDirectivePrefix()
513        << Dir.getFormattedName() << ",\n";
514     OS << "      llvm::" << DirLang.getCppNamespace() << "::requiredClauses_"
515        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
516     OS << "    }\n";
517     OS << "  },\n";
518   }
519 
520   OS << "}\n";
521 }
522 
523 // Generate classes entry for Flang clauses in the Flang parse-tree
524 // If the clause as a non-generic class, no entry is generated.
525 // If the clause does not hold a value, an EMPTY_CLASS is used.
526 // If the clause class is generic then a WRAPPER_CLASS is used. When the value
527 // is optional, the value class is wrapped into a std::optional.
528 void GenerateFlangClauseParserClass(const DirectiveLanguage &DirLang,
529                                     raw_ostream &OS) {
530 
531   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS);
532 
533   OS << "\n";
534 
535   for (const auto &C : DirLang.getClauses()) {
536     Clause Clause{C};
537     if (!Clause.getFlangClass().empty()) {
538       OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
539       if (Clause.isValueOptional() && Clause.isValueList()) {
540         OS << "std::optional<std::list<" << Clause.getFlangClass() << ">>";
541       } else if (Clause.isValueOptional()) {
542         OS << "std::optional<" << Clause.getFlangClass() << ">";
543       } else if (Clause.isValueList()) {
544         OS << "std::list<" << Clause.getFlangClass() << ">";
545       } else {
546         OS << Clause.getFlangClass();
547       }
548     } else {
549       OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
550     }
551     OS << ");\n";
552   }
553 }
554 
555 // Generate a list of the different clause classes for Flang.
556 void GenerateFlangClauseParserClassList(const DirectiveLanguage &DirLang,
557                                         raw_ostream &OS) {
558 
559   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
560 
561   OS << "\n";
562   llvm::interleaveComma(DirLang.getClauses(), OS, [&](Record *C) {
563     Clause Clause{C};
564     OS << Clause.getFormattedParserClassName() << "\n";
565   });
566 }
567 
568 // Generate dump node list for the clauses holding a generic class name.
569 void GenerateFlangClauseDump(const DirectiveLanguage &DirLang,
570                              raw_ostream &OS) {
571 
572   IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS);
573 
574   OS << "\n";
575   for (const auto &C : DirLang.getClauses()) {
576     Clause Clause{C};
577     OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", "
578        << Clause.getFormattedParserClassName() << ")\n";
579   }
580 }
581 
582 // Generate Unparse functions for clauses classes in the Flang parse-tree
583 // If the clause is a non-generic class, no entry is generated.
584 void GenerateFlangClauseUnparse(const DirectiveLanguage &DirLang,
585                                 raw_ostream &OS) {
586 
587   IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
588 
589   OS << "\n";
590 
591   for (const auto &C : DirLang.getClauses()) {
592     Clause Clause{C};
593     if (!Clause.getFlangClass().empty()) {
594       if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) {
595         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
596            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
597         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
598 
599         OS << "  Walk(\"(\", x.v, \")\");\n";
600         OS << "}\n";
601       } else if (Clause.isValueOptional()) {
602         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
603            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
604         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
605         OS << "  Put(\"(\");\n";
606         OS << "  if (x.v.has_value())\n";
607         if (Clause.isValueList())
608           OS << "    Walk(x.v, \",\");\n";
609         else
610           OS << "    Walk(x.v);\n";
611         OS << "  else\n";
612         OS << "    Put(\"" << Clause.getDefaultValue() << "\");\n";
613         OS << "  Put(\")\");\n";
614         OS << "}\n";
615       } else {
616         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
617            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
618         OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
619         OS << "  Put(\"(\");\n";
620         if (Clause.isValueList())
621           OS << "  Walk(x.v, \",\");\n";
622         else
623           OS << "  Walk(x.v);\n";
624         OS << "  Put(\")\");\n";
625         OS << "}\n";
626       }
627     } else {
628       OS << "void Before(const " << DirLang.getFlangClauseBaseClass()
629          << "::" << Clause.getFormattedParserClassName() << " &) { Word(\""
630          << Clause.getName().upper() << "\"); }\n";
631     }
632   }
633 }
634 
635 // Generate check in the Enter functions for clauses classes.
636 void GenerateFlangClauseCheckPrototypes(const DirectiveLanguage &DirLang,
637                                         raw_ostream &OS) {
638 
639   IfDefScope Scope("GEN_FLANG_CLAUSE_CHECK_ENTER", OS);
640 
641   OS << "\n";
642   for (const auto &C : DirLang.getClauses()) {
643     Clause Clause{C};
644     OS << "void Enter(const parser::" << DirLang.getFlangClauseBaseClass()
645        << "::" << Clause.getFormattedParserClassName() << " &);\n";
646   }
647 }
648 
649 // Generate the mapping for clauses between the parser class and the
650 // corresponding clause Kind
651 void GenerateFlangClauseParserKindMap(const DirectiveLanguage &DirLang,
652                                       raw_ostream &OS) {
653 
654   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_KIND_MAP", OS);
655 
656   OS << "\n";
657   for (const auto &C : DirLang.getClauses()) {
658     Clause Clause{C};
659     OS << "if constexpr (std::is_same_v<A, parser::"
660        << DirLang.getFlangClauseBaseClass()
661        << "::" << Clause.getFormattedParserClassName();
662     OS << ">)\n";
663     OS << "  return llvm::" << DirLang.getCppNamespace()
664        << "::Clause::" << DirLang.getClausePrefix() << Clause.getFormattedName()
665        << ";\n";
666   }
667 
668   OS << "llvm_unreachable(\"Invalid " << DirLang.getName()
669      << " Parser clause\");\n";
670 }
671 
672 bool compareClauseName(Record *R1, Record *R2) {
673   Clause C1{R1};
674   Clause C2{R2};
675   return (C1.getName() > C2.getName());
676 }
677 
678 // Generate the parser for the clauses.
679 void GenerateFlangClausesParser(const DirectiveLanguage &DirLang,
680                                 raw_ostream &OS) {
681   std::vector<Record *> Clauses = DirLang.getClauses();
682   // Sort clauses in reverse alphabetical order so with clauses with same
683   // beginning, the longer option is tried before.
684   llvm::sort(Clauses, compareClauseName);
685   IfDefScope Scope("GEN_FLANG_CLAUSES_PARSER", OS);
686   OS << "\n";
687   unsigned index = 0;
688   unsigned lastClauseIndex = DirLang.getClauses().size() - 1;
689   OS << "TYPE_PARSER(\n";
690   for (const auto &C : Clauses) {
691     Clause Clause{C};
692     if (Clause.getAliases().empty()) {
693       OS << "  \"" << Clause.getName() << "\"";
694     } else {
695       OS << "  ("
696          << "\"" << Clause.getName() << "\"_tok";
697       for (StringRef alias : Clause.getAliases()) {
698         OS << " || \"" << alias << "\"_tok";
699       }
700       OS << ")";
701     }
702 
703     OS << " >> construct<" << DirLang.getFlangClauseBaseClass()
704        << ">(construct<" << DirLang.getFlangClauseBaseClass()
705        << "::" << Clause.getFormattedParserClassName() << ">(";
706     if (Clause.getFlangClass().empty()) {
707       OS << "))";
708       if (index != lastClauseIndex)
709         OS << " ||";
710       OS << "\n";
711       ++index;
712       continue;
713     }
714 
715     if (Clause.isValueOptional())
716       OS << "maybe(";
717     OS << "parenthesized(";
718 
719     if (!Clause.getPrefix().empty())
720       OS << "\"" << Clause.getPrefix() << ":\" >> ";
721 
722     // The common Flang parser are used directly. Their name is identical to
723     // the Flang class with first letter as lowercase. If the Flang class is
724     // not a common class, we assume there is a specific Parser<>{} with the
725     // Flang class name provided.
726     llvm::SmallString<128> Scratch;
727     StringRef Parser =
728         llvm::StringSwitch<StringRef>(Clause.getFlangClass())
729             .Case("Name", "name")
730             .Case("ScalarIntConstantExpr", "scalarIntConstantExpr")
731             .Case("ScalarIntExpr", "scalarIntExpr")
732             .Case("ScalarLogicalExpr", "scalarLogicalExpr")
733             .Default(("Parser<" + Clause.getFlangClass() + ">{}")
734                          .toStringRef(Scratch));
735     OS << Parser;
736     if (!Clause.getPrefix().empty() && Clause.isPrefixOptional())
737       OS << " || " << Parser;
738     OS << ")"; // close parenthesized(.
739 
740     if (Clause.isValueOptional()) // close maybe(.
741       OS << ")";
742     OS << "))";
743     if (index != lastClauseIndex)
744       OS << " ||";
745     OS << "\n";
746     ++index;
747   }
748   OS << ")\n";
749 }
750 
751 // Generate the implementation section for the enumeration in the directive
752 // language
753 void EmitDirectivesFlangImpl(const DirectiveLanguage &DirLang,
754                              raw_ostream &OS) {
755 
756   GenerateDirectiveClauseSets(DirLang, OS);
757 
758   GenerateDirectiveClauseMap(DirLang, OS);
759 
760   GenerateFlangClauseParserClass(DirLang, OS);
761 
762   GenerateFlangClauseParserClassList(DirLang, OS);
763 
764   GenerateFlangClauseDump(DirLang, OS);
765 
766   GenerateFlangClauseUnparse(DirLang, OS);
767 
768   GenerateFlangClauseCheckPrototypes(DirLang, OS);
769 
770   GenerateFlangClauseParserKindMap(DirLang, OS);
771 
772   GenerateFlangClausesParser(DirLang, OS);
773 }
774 
775 void GenerateClauseClassMacro(const DirectiveLanguage &DirLang,
776                               raw_ostream &OS) {
777   // Generate macros style information for legacy code in clang
778   IfDefScope Scope("GEN_CLANG_CLAUSE_CLASS", OS);
779 
780   OS << "\n";
781 
782   OS << "#ifndef CLAUSE\n";
783   OS << "#define CLAUSE(Enum, Str, Implicit)\n";
784   OS << "#endif\n";
785   OS << "#ifndef CLAUSE_CLASS\n";
786   OS << "#define CLAUSE_CLASS(Enum, Str, Class)\n";
787   OS << "#endif\n";
788   OS << "#ifndef CLAUSE_NO_CLASS\n";
789   OS << "#define CLAUSE_NO_CLASS(Enum, Str)\n";
790   OS << "#endif\n";
791   OS << "\n";
792   OS << "#define __CLAUSE(Name, Class)                      \\\n";
793   OS << "  CLAUSE(" << DirLang.getClausePrefix()
794      << "##Name, #Name, /* Implicit */ false) \\\n";
795   OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix()
796      << "##Name, #Name, Class)\n";
797   OS << "#define __CLAUSE_NO_CLASS(Name)                    \\\n";
798   OS << "  CLAUSE(" << DirLang.getClausePrefix()
799      << "##Name, #Name, /* Implicit */ false) \\\n";
800   OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, #Name)\n";
801   OS << "#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \\\n";
802   OS << "  CLAUSE(" << DirLang.getClausePrefix()
803      << "##Name, Str, /* Implicit */ true)    \\\n";
804   OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix()
805      << "##Name, Str, Class)\n";
806   OS << "#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \\\n";
807   OS << "  CLAUSE(" << DirLang.getClausePrefix()
808      << "##Name, Str, /* Implicit */ true)    \\\n";
809   OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, Str)\n";
810   OS << "\n";
811 
812   for (const auto &R : DirLang.getClauses()) {
813     Clause C{R};
814     if (C.getClangClass().empty()) { // NO_CLASS
815       if (C.isImplicit()) {
816         OS << "__IMPLICIT_CLAUSE_NO_CLASS(" << C.getFormattedName() << ", \""
817            << C.getFormattedName() << "\")\n";
818       } else {
819         OS << "__CLAUSE_NO_CLASS(" << C.getFormattedName() << ")\n";
820       }
821     } else { // CLASS
822       if (C.isImplicit()) {
823         OS << "__IMPLICIT_CLAUSE_CLASS(" << C.getFormattedName() << ", \""
824            << C.getFormattedName() << "\", " << C.getClangClass() << ")\n";
825       } else {
826         OS << "__CLAUSE(" << C.getFormattedName() << ", " << C.getClangClass()
827            << ")\n";
828       }
829     }
830   }
831 
832   OS << "\n";
833   OS << "#undef __IMPLICIT_CLAUSE_NO_CLASS\n";
834   OS << "#undef __IMPLICIT_CLAUSE_CLASS\n";
835   OS << "#undef __CLAUSE\n";
836   OS << "#undef CLAUSE_NO_CLASS\n";
837   OS << "#undef CLAUSE_CLASS\n";
838   OS << "#undef CLAUSE\n";
839 }
840 
841 // Generate the implemenation for the enumeration in the directive
842 // language. This code can be included in library.
843 void EmitDirectivesBasicImpl(const DirectiveLanguage &DirLang,
844                              raw_ostream &OS) {
845   IfDefScope Scope("GEN_DIRECTIVES_IMPL", OS);
846 
847   // getDirectiveKind(StringRef Str)
848   GenerateGetKind(DirLang.getDirectives(), OS, "Directive", DirLang,
849                   DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false);
850 
851   // getDirectiveName(Directive Kind)
852   GenerateGetName(DirLang.getDirectives(), OS, "Directive", DirLang,
853                   DirLang.getDirectivePrefix());
854 
855   // getClauseKind(StringRef Str)
856   GenerateGetKind(DirLang.getClauses(), OS, "Clause", DirLang,
857                   DirLang.getClausePrefix(),
858                   /*ImplicitAsUnknown=*/true);
859 
860   // getClauseName(Clause Kind)
861   GenerateGetName(DirLang.getClauses(), OS, "Clause", DirLang,
862                   DirLang.getClausePrefix());
863 
864   // get<ClauseVal>Kind(StringRef Str)
865   GenerateGetKindClauseVal(DirLang, OS);
866 
867   // isAllowedClauseForDirective(Directive D, Clause C, unsigned Version)
868   GenerateIsAllowedClause(DirLang, OS);
869 }
870 
871 // Generate the implemenation section for the enumeration in the directive
872 // language.
873 void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
874   const auto DirLang = DirectiveLanguage{Records};
875   if (DirLang.HasValidityErrors())
876     return;
877 
878   EmitDirectivesFlangImpl(DirLang, OS);
879 
880   GenerateClauseClassMacro(DirLang, OS);
881 
882   EmitDirectivesBasicImpl(DirLang, OS);
883 }
884 
885 } // namespace llvm
886