• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //=- ClangDiagnosticsEmitter.cpp - Generate Clang diagnostics tables -*- C++ -*-
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // These tablegen backends emit Clang diagnostics tables.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/DenseSet.h"
15 #include "llvm/ADT/Optional.h"
16 #include "llvm/ADT/PointerUnion.h"
17 #include "llvm/ADT/SetVector.h"
18 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/Twine.h"
23 #include "llvm/Support/Compiler.h"
24 #include "llvm/Support/Debug.h"
25 #include "llvm/TableGen/Error.h"
26 #include "llvm/TableGen/Record.h"
27 #include "llvm/TableGen/StringToOffsetTable.h"
28 #include "llvm/TableGen/TableGenBackend.h"
29 #include <algorithm>
30 #include <cctype>
31 #include <functional>
32 #include <map>
33 #include <set>
34 using namespace llvm;
35 
36 //===----------------------------------------------------------------------===//
37 // Diagnostic category computation code.
38 //===----------------------------------------------------------------------===//
39 
40 namespace {
41 class DiagGroupParentMap {
42   RecordKeeper &Records;
43   std::map<const Record*, std::vector<Record*> > Mapping;
44 public:
DiagGroupParentMap(RecordKeeper & records)45   DiagGroupParentMap(RecordKeeper &records) : Records(records) {
46     std::vector<Record*> DiagGroups
47       = Records.getAllDerivedDefinitions("DiagGroup");
48     for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
49       std::vector<Record*> SubGroups =
50         DiagGroups[i]->getValueAsListOfDefs("SubGroups");
51       for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
52         Mapping[SubGroups[j]].push_back(DiagGroups[i]);
53     }
54   }
55 
getParents(const Record * Group)56   const std::vector<Record*> &getParents(const Record *Group) {
57     return Mapping[Group];
58   }
59 };
60 } // end anonymous namespace.
61 
62 static std::string
getCategoryFromDiagGroup(const Record * Group,DiagGroupParentMap & DiagGroupParents)63 getCategoryFromDiagGroup(const Record *Group,
64                          DiagGroupParentMap &DiagGroupParents) {
65   // If the DiagGroup has a category, return it.
66   std::string CatName = Group->getValueAsString("CategoryName");
67   if (!CatName.empty()) return CatName;
68 
69   // The diag group may the subgroup of one or more other diagnostic groups,
70   // check these for a category as well.
71   const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
72   for (unsigned i = 0, e = Parents.size(); i != e; ++i) {
73     CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents);
74     if (!CatName.empty()) return CatName;
75   }
76   return "";
77 }
78 
79 /// getDiagnosticCategory - Return the category that the specified diagnostic
80 /// lives in.
getDiagnosticCategory(const Record * R,DiagGroupParentMap & DiagGroupParents)81 static std::string getDiagnosticCategory(const Record *R,
82                                          DiagGroupParentMap &DiagGroupParents) {
83   // If the diagnostic is in a group, and that group has a category, use it.
84   if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
85     // Check the diagnostic's diag group for a category.
86     std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
87                                                    DiagGroupParents);
88     if (!CatName.empty()) return CatName;
89   }
90 
91   // If the diagnostic itself has a category, get it.
92   return R->getValueAsString("CategoryName");
93 }
94 
95 namespace {
96   class DiagCategoryIDMap {
97     RecordKeeper &Records;
98     StringMap<unsigned> CategoryIDs;
99     std::vector<std::string> CategoryStrings;
100   public:
DiagCategoryIDMap(RecordKeeper & records)101     DiagCategoryIDMap(RecordKeeper &records) : Records(records) {
102       DiagGroupParentMap ParentInfo(Records);
103 
104       // The zero'th category is "".
105       CategoryStrings.push_back("");
106       CategoryIDs[""] = 0;
107 
108       std::vector<Record*> Diags =
109       Records.getAllDerivedDefinitions("Diagnostic");
110       for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
111         std::string Category = getDiagnosticCategory(Diags[i], ParentInfo);
112         if (Category.empty()) continue;  // Skip diags with no category.
113 
114         unsigned &ID = CategoryIDs[Category];
115         if (ID != 0) continue;  // Already seen.
116 
117         ID = CategoryStrings.size();
118         CategoryStrings.push_back(Category);
119       }
120     }
121 
getID(StringRef CategoryString)122     unsigned getID(StringRef CategoryString) {
123       return CategoryIDs[CategoryString];
124     }
125 
126     typedef std::vector<std::string>::const_iterator const_iterator;
begin() const127     const_iterator begin() const { return CategoryStrings.begin(); }
end() const128     const_iterator end() const { return CategoryStrings.end(); }
129   };
130 
131   struct GroupInfo {
132     std::vector<const Record*> DiagsInGroup;
133     std::vector<std::string> SubGroups;
134     unsigned IDNo;
135 
136     const Record *ExplicitDef;
137 
GroupInfo__anon9ee1e1fd0211::GroupInfo138     GroupInfo() : ExplicitDef(nullptr) {}
139   };
140 } // end anonymous namespace.
141 
beforeThanCompare(const Record * LHS,const Record * RHS)142 static bool beforeThanCompare(const Record *LHS, const Record *RHS) {
143   assert(!LHS->getLoc().empty() && !RHS->getLoc().empty());
144   return
145     LHS->getLoc().front().getPointer() < RHS->getLoc().front().getPointer();
146 }
147 
beforeThanCompareGroups(const GroupInfo * LHS,const GroupInfo * RHS)148 static bool beforeThanCompareGroups(const GroupInfo *LHS, const GroupInfo *RHS){
149   assert(!LHS->DiagsInGroup.empty() && !RHS->DiagsInGroup.empty());
150   return beforeThanCompare(LHS->DiagsInGroup.front(),
151                            RHS->DiagsInGroup.front());
152 }
153 
findSuperClassRange(const Record * R,StringRef SuperName)154 static SMRange findSuperClassRange(const Record *R, StringRef SuperName) {
155   ArrayRef<std::pair<Record *, SMRange>> Supers = R->getSuperClasses();
156   auto I = std::find_if(Supers.begin(), Supers.end(),
157                         [&](const std::pair<Record *, SMRange> &SuperPair) {
158                           return SuperPair.first->getName() == SuperName;
159                         });
160   return (I != Supers.end()) ? I->second : SMRange();
161 }
162 
163 /// \brief Invert the 1-[0/1] mapping of diags to group into a one to many
164 /// mapping of groups to diags in the group.
groupDiagnostics(const std::vector<Record * > & Diags,const std::vector<Record * > & DiagGroups,std::map<std::string,GroupInfo> & DiagsInGroup)165 static void groupDiagnostics(const std::vector<Record*> &Diags,
166                              const std::vector<Record*> &DiagGroups,
167                              std::map<std::string, GroupInfo> &DiagsInGroup) {
168 
169   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
170     const Record *R = Diags[i];
171     DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group"));
172     if (!DI)
173       continue;
174     assert(R->getValueAsDef("Class")->getName() != "CLASS_NOTE" &&
175            "Note can't be in a DiagGroup");
176     std::string GroupName = DI->getDef()->getValueAsString("GroupName");
177     DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
178   }
179 
180   typedef SmallPtrSet<GroupInfo *, 16> GroupSetTy;
181   GroupSetTy ImplicitGroups;
182 
183   // Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty
184   // groups (these are warnings that GCC supports that clang never produces).
185   for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
186     Record *Group = DiagGroups[i];
187     GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
188     if (Group->isAnonymous()) {
189       if (GI.DiagsInGroup.size() > 1)
190         ImplicitGroups.insert(&GI);
191     } else {
192       if (GI.ExplicitDef)
193         assert(GI.ExplicitDef == Group);
194       else
195         GI.ExplicitDef = Group;
196     }
197 
198     std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
199     for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
200       GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
201   }
202 
203   // Assign unique ID numbers to the groups.
204   unsigned IDNo = 0;
205   for (std::map<std::string, GroupInfo>::iterator
206        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
207     I->second.IDNo = IDNo;
208 
209   // Sort the implicit groups, so we can warn about them deterministically.
210   SmallVector<GroupInfo *, 16> SortedGroups(ImplicitGroups.begin(),
211                                             ImplicitGroups.end());
212   for (SmallVectorImpl<GroupInfo *>::iterator I = SortedGroups.begin(),
213                                               E = SortedGroups.end();
214        I != E; ++I) {
215     MutableArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
216     std::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare);
217   }
218   std::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups);
219 
220   // Warn about the same group being used anonymously in multiple places.
221   for (SmallVectorImpl<GroupInfo *>::const_iterator I = SortedGroups.begin(),
222                                                     E = SortedGroups.end();
223        I != E; ++I) {
224     ArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
225 
226     if ((*I)->ExplicitDef) {
227       std::string Name = (*I)->ExplicitDef->getValueAsString("GroupName");
228       for (ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
229                                                     DE = GroupDiags.end();
230            DI != DE; ++DI) {
231         const DefInit *GroupInit = cast<DefInit>((*DI)->getValueInit("Group"));
232         const Record *NextDiagGroup = GroupInit->getDef();
233         if (NextDiagGroup == (*I)->ExplicitDef)
234           continue;
235 
236         SMRange InGroupRange = findSuperClassRange(*DI, "InGroup");
237         SmallString<64> Replacement;
238         if (InGroupRange.isValid()) {
239           Replacement += "InGroup<";
240           Replacement += (*I)->ExplicitDef->getName();
241           Replacement += ">";
242         }
243         SMFixIt FixIt(InGroupRange, Replacement);
244 
245         SrcMgr.PrintMessage(NextDiagGroup->getLoc().front(),
246                             SourceMgr::DK_Error,
247                             Twine("group '") + Name +
248                               "' is referred to anonymously",
249                             None,
250                             InGroupRange.isValid() ? FixIt
251                                                    : ArrayRef<SMFixIt>());
252         SrcMgr.PrintMessage((*I)->ExplicitDef->getLoc().front(),
253                             SourceMgr::DK_Note, "group defined here");
254       }
255     } else {
256       // If there's no existing named group, we should just warn once and use
257       // notes to list all the other cases.
258       ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
259                                                DE = GroupDiags.end();
260       assert(DI != DE && "We only care about groups with multiple uses!");
261 
262       const DefInit *GroupInit = cast<DefInit>((*DI)->getValueInit("Group"));
263       const Record *NextDiagGroup = GroupInit->getDef();
264       std::string Name = NextDiagGroup->getValueAsString("GroupName");
265 
266       SMRange InGroupRange = findSuperClassRange(*DI, "InGroup");
267       SrcMgr.PrintMessage(NextDiagGroup->getLoc().front(),
268                           SourceMgr::DK_Error,
269                           Twine("group '") + Name +
270                             "' is referred to anonymously",
271                           InGroupRange);
272 
273       for (++DI; DI != DE; ++DI) {
274         GroupInit = cast<DefInit>((*DI)->getValueInit("Group"));
275         InGroupRange = findSuperClassRange(*DI, "InGroup");
276         SrcMgr.PrintMessage(GroupInit->getDef()->getLoc().front(),
277                             SourceMgr::DK_Note, "also referenced here",
278                             InGroupRange);
279       }
280     }
281   }
282 }
283 
284 //===----------------------------------------------------------------------===//
285 // Infer members of -Wpedantic.
286 //===----------------------------------------------------------------------===//
287 
288 typedef std::vector<const Record *> RecordVec;
289 typedef llvm::DenseSet<const Record *> RecordSet;
290 typedef llvm::PointerUnion<RecordVec*, RecordSet*> VecOrSet;
291 
292 namespace {
293 class InferPedantic {
294   typedef llvm::DenseMap<const Record*,
295                          std::pair<unsigned, Optional<unsigned> > > GMap;
296 
297   DiagGroupParentMap &DiagGroupParents;
298   const std::vector<Record*> &Diags;
299   const std::vector<Record*> DiagGroups;
300   std::map<std::string, GroupInfo> &DiagsInGroup;
301   llvm::DenseSet<const Record*> DiagsSet;
302   GMap GroupCount;
303 public:
InferPedantic(DiagGroupParentMap & DiagGroupParents,const std::vector<Record * > & Diags,const std::vector<Record * > & DiagGroups,std::map<std::string,GroupInfo> & DiagsInGroup)304   InferPedantic(DiagGroupParentMap &DiagGroupParents,
305                 const std::vector<Record*> &Diags,
306                 const std::vector<Record*> &DiagGroups,
307                 std::map<std::string, GroupInfo> &DiagsInGroup)
308   : DiagGroupParents(DiagGroupParents),
309   Diags(Diags),
310   DiagGroups(DiagGroups),
311   DiagsInGroup(DiagsInGroup) {}
312 
313   /// Compute the set of diagnostics and groups that are immediately
314   /// in -Wpedantic.
315   void compute(VecOrSet DiagsInPedantic,
316                VecOrSet GroupsInPedantic);
317 
318 private:
319   /// Determine whether a group is a subgroup of another group.
320   bool isSubGroupOfGroup(const Record *Group,
321                          llvm::StringRef RootGroupName);
322 
323   /// Determine if the diagnostic is an extension.
324   bool isExtension(const Record *Diag);
325 
326   /// Determine if the diagnostic is off by default.
327   bool isOffByDefault(const Record *Diag);
328 
329   /// Increment the count for a group, and transitively marked
330   /// parent groups when appropriate.
331   void markGroup(const Record *Group);
332 
333   /// Return true if the diagnostic is in a pedantic group.
334   bool groupInPedantic(const Record *Group, bool increment = false);
335 };
336 } // end anonymous namespace
337 
isSubGroupOfGroup(const Record * Group,llvm::StringRef GName)338 bool InferPedantic::isSubGroupOfGroup(const Record *Group,
339                                       llvm::StringRef GName) {
340 
341   const std::string &GroupName = Group->getValueAsString("GroupName");
342   if (GName == GroupName)
343     return true;
344 
345   const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
346   for (unsigned i = 0, e = Parents.size(); i != e; ++i)
347     if (isSubGroupOfGroup(Parents[i], GName))
348       return true;
349 
350   return false;
351 }
352 
353 /// Determine if the diagnostic is an extension.
isExtension(const Record * Diag)354 bool InferPedantic::isExtension(const Record *Diag) {
355   const std::string &ClsName = Diag->getValueAsDef("Class")->getName();
356   return ClsName == "CLASS_EXTENSION";
357 }
358 
isOffByDefault(const Record * Diag)359 bool InferPedantic::isOffByDefault(const Record *Diag) {
360   const std::string &DefSeverity =
361       Diag->getValueAsDef("DefaultSeverity")->getValueAsString("Name");
362   return DefSeverity == "Ignored";
363 }
364 
groupInPedantic(const Record * Group,bool increment)365 bool InferPedantic::groupInPedantic(const Record *Group, bool increment) {
366   GMap::mapped_type &V = GroupCount[Group];
367   // Lazily compute the threshold value for the group count.
368   if (!V.second.hasValue()) {
369     const GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
370     V.second = GI.SubGroups.size() + GI.DiagsInGroup.size();
371   }
372 
373   if (increment)
374     ++V.first;
375 
376   // Consider a group in -Wpendatic IFF if has at least one diagnostic
377   // or subgroup AND all of those diagnostics and subgroups are covered
378   // by -Wpedantic via our computation.
379   return V.first != 0 && V.first == V.second.getValue();
380 }
381 
markGroup(const Record * Group)382 void InferPedantic::markGroup(const Record *Group) {
383   // If all the diagnostics and subgroups have been marked as being
384   // covered by -Wpedantic, increment the count of parent groups.  Once the
385   // group's count is equal to the number of subgroups and diagnostics in
386   // that group, we can safely add this group to -Wpedantic.
387   if (groupInPedantic(Group, /* increment */ true)) {
388     const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
389     for (unsigned i = 0, e = Parents.size(); i != e; ++i)
390       markGroup(Parents[i]);
391   }
392 }
393 
compute(VecOrSet DiagsInPedantic,VecOrSet GroupsInPedantic)394 void InferPedantic::compute(VecOrSet DiagsInPedantic,
395                             VecOrSet GroupsInPedantic) {
396   // All extensions that are not on by default are implicitly in the
397   // "pedantic" group.  For those that aren't explicitly included in -Wpedantic,
398   // mark them for consideration to be included in -Wpedantic directly.
399   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
400     Record *R = Diags[i];
401     if (isExtension(R) && isOffByDefault(R)) {
402       DiagsSet.insert(R);
403       if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
404         const Record *GroupRec = Group->getDef();
405         if (!isSubGroupOfGroup(GroupRec, "pedantic")) {
406           markGroup(GroupRec);
407         }
408       }
409     }
410   }
411 
412   // Compute the set of diagnostics that are directly in -Wpedantic.  We
413   // march through Diags a second time to ensure the results are emitted
414   // in deterministic order.
415   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
416     Record *R = Diags[i];
417     if (!DiagsSet.count(R))
418       continue;
419     // Check if the group is implicitly in -Wpedantic.  If so,
420     // the diagnostic should not be directly included in the -Wpedantic
421     // diagnostic group.
422     if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group")))
423       if (groupInPedantic(Group->getDef()))
424         continue;
425 
426     // The diagnostic is not included in a group that is (transitively) in
427     // -Wpedantic.  Include it in -Wpedantic directly.
428     if (RecordVec *V = DiagsInPedantic.dyn_cast<RecordVec*>())
429       V->push_back(R);
430     else {
431       DiagsInPedantic.get<RecordSet*>()->insert(R);
432     }
433   }
434 
435   if (!GroupsInPedantic)
436     return;
437 
438   // Compute the set of groups that are directly in -Wpedantic.  We
439   // march through the groups to ensure the results are emitted
440   /// in a deterministc order.
441   for (unsigned i = 0, ei = DiagGroups.size(); i != ei; ++i) {
442     Record *Group = DiagGroups[i];
443     if (!groupInPedantic(Group))
444       continue;
445 
446     unsigned ParentsInPedantic = 0;
447     const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
448     for (unsigned j = 0, ej = Parents.size(); j != ej; ++j) {
449       if (groupInPedantic(Parents[j]))
450         ++ParentsInPedantic;
451     }
452     // If all the parents are in -Wpedantic, this means that this diagnostic
453     // group will be indirectly included by -Wpedantic already.  In that
454     // case, do not add it directly to -Wpedantic.  If the group has no
455     // parents, obviously it should go into -Wpedantic.
456     if (Parents.size() > 0 && ParentsInPedantic == Parents.size())
457       continue;
458 
459     if (RecordVec *V = GroupsInPedantic.dyn_cast<RecordVec*>())
460       V->push_back(Group);
461     else {
462       GroupsInPedantic.get<RecordSet*>()->insert(Group);
463     }
464   }
465 }
466 
467 //===----------------------------------------------------------------------===//
468 // Warning Tables (.inc file) generation.
469 //===----------------------------------------------------------------------===//
470 
isError(const Record & Diag)471 static bool isError(const Record &Diag) {
472   const std::string &ClsName = Diag.getValueAsDef("Class")->getName();
473   return ClsName == "CLASS_ERROR";
474 }
475 
isRemark(const Record & Diag)476 static bool isRemark(const Record &Diag) {
477   const std::string &ClsName = Diag.getValueAsDef("Class")->getName();
478   return ClsName == "CLASS_REMARK";
479 }
480 
481 /// ClangDiagsDefsEmitter - The top-level class emits .def files containing
482 /// declarations of Clang diagnostics.
483 namespace clang {
EmitClangDiagsDefs(RecordKeeper & Records,raw_ostream & OS,const std::string & Component)484 void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
485                         const std::string &Component) {
486   // Write the #if guard
487   if (!Component.empty()) {
488     std::string ComponentName = StringRef(Component).upper();
489     OS << "#ifdef " << ComponentName << "START\n";
490     OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName
491        << ",\n";
492     OS << "#undef " << ComponentName << "START\n";
493     OS << "#endif\n\n";
494   }
495 
496   const std::vector<Record*> &Diags =
497     Records.getAllDerivedDefinitions("Diagnostic");
498 
499   std::vector<Record*> DiagGroups
500     = Records.getAllDerivedDefinitions("DiagGroup");
501 
502   std::map<std::string, GroupInfo> DiagsInGroup;
503   groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
504 
505   DiagCategoryIDMap CategoryIDs(Records);
506   DiagGroupParentMap DGParentMap(Records);
507 
508   // Compute the set of diagnostics that are in -Wpedantic.
509   RecordSet DiagsInPedantic;
510   InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
511   inferPedantic.compute(&DiagsInPedantic, (RecordVec*)nullptr);
512 
513   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
514     const Record &R = *Diags[i];
515 
516     // Check if this is an error that is accidentally in a warning
517     // group.
518     if (isError(R)) {
519       if (DefInit *Group = dyn_cast<DefInit>(R.getValueInit("Group"))) {
520         const Record *GroupRec = Group->getDef();
521         const std::string &GroupName = GroupRec->getValueAsString("GroupName");
522         PrintFatalError(R.getLoc(), "Error " + R.getName() +
523                       " cannot be in a warning group [" + GroupName + "]");
524       }
525     }
526 
527     // Check that all remarks have an associated diagnostic group.
528     if (isRemark(R)) {
529       if (!isa<DefInit>(R.getValueInit("Group"))) {
530         PrintFatalError(R.getLoc(), "Error " + R.getName() +
531                                         " not in any diagnostic group");
532       }
533     }
534 
535     // Filter by component.
536     if (!Component.empty() && Component != R.getValueAsString("Component"))
537       continue;
538 
539     OS << "DIAG(" << R.getName() << ", ";
540     OS << R.getValueAsDef("Class")->getName();
541     OS << ", (unsigned)diag::Severity::"
542        << R.getValueAsDef("DefaultSeverity")->getValueAsString("Name");
543 
544     // Description string.
545     OS << ", \"";
546     OS.write_escaped(R.getValueAsString("Text")) << '"';
547 
548     // Warning associated with the diagnostic. This is stored as an index into
549     // the alphabetically sorted warning table.
550     if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group"))) {
551       std::map<std::string, GroupInfo>::iterator I =
552           DiagsInGroup.find(DI->getDef()->getValueAsString("GroupName"));
553       assert(I != DiagsInGroup.end());
554       OS << ", " << I->second.IDNo;
555     } else if (DiagsInPedantic.count(&R)) {
556       std::map<std::string, GroupInfo>::iterator I =
557         DiagsInGroup.find("pedantic");
558       assert(I != DiagsInGroup.end() && "pedantic group not defined");
559       OS << ", " << I->second.IDNo;
560     } else {
561       OS << ", 0";
562     }
563 
564     // SFINAE response.
565     OS << ", " << R.getValueAsDef("SFINAE")->getName();
566 
567     // Default warning has no Werror bit.
568     if (R.getValueAsBit("WarningNoWerror"))
569       OS << ", true";
570     else
571       OS << ", false";
572 
573     if (R.getValueAsBit("ShowInSystemHeader"))
574       OS << ", true";
575     else
576       OS << ", false";
577 
578     // Category number.
579     OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
580     OS << ")\n";
581   }
582 }
583 } // end namespace clang
584 
585 //===----------------------------------------------------------------------===//
586 // Warning Group Tables generation
587 //===----------------------------------------------------------------------===//
588 
getDiagCategoryEnum(llvm::StringRef name)589 static std::string getDiagCategoryEnum(llvm::StringRef name) {
590   if (name.empty())
591     return "DiagCat_None";
592   SmallString<256> enumName = llvm::StringRef("DiagCat_");
593   for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
594     enumName += isalnum(*I) ? *I : '_';
595   return enumName.str();
596 }
597 
598 /// \brief Emit the array of diagnostic subgroups.
599 ///
600 /// The array of diagnostic subgroups contains for each group a list of its
601 /// subgroups. The individual lists are separated by '-1'. Groups with no
602 /// subgroups are skipped.
603 ///
604 /// \code
605 ///   static const int16_t DiagSubGroups[] = {
606 ///     /* Empty */ -1,
607 ///     /* DiagSubGroup0 */ 142, -1,
608 ///     /* DiagSubGroup13 */ 265, 322, 399, -1
609 ///   }
610 /// \endcode
611 ///
emitDiagSubGroups(std::map<std::string,GroupInfo> & DiagsInGroup,RecordVec & GroupsInPedantic,raw_ostream & OS)612 static void emitDiagSubGroups(std::map<std::string, GroupInfo> &DiagsInGroup,
613                               RecordVec &GroupsInPedantic, raw_ostream &OS) {
614   OS << "static const int16_t DiagSubGroups[] = {\n"
615      << "  /* Empty */ -1,\n";
616   for (auto const &I : DiagsInGroup) {
617     const bool IsPedantic = I.first == "pedantic";
618 
619     const std::vector<std::string> &SubGroups = I.second.SubGroups;
620     if (!SubGroups.empty() || (IsPedantic && !GroupsInPedantic.empty())) {
621       OS << "  /* DiagSubGroup" << I.second.IDNo << " */ ";
622       for (auto const &SubGroup : SubGroups) {
623         std::map<std::string, GroupInfo>::const_iterator RI =
624             DiagsInGroup.find(SubGroup);
625         assert(RI != DiagsInGroup.end() && "Referenced without existing?");
626         OS << RI->second.IDNo << ", ";
627       }
628       // Emit the groups implicitly in "pedantic".
629       if (IsPedantic) {
630         for (auto const &Group : GroupsInPedantic) {
631           const std::string &GroupName = Group->getValueAsString("GroupName");
632           std::map<std::string, GroupInfo>::const_iterator RI =
633               DiagsInGroup.find(GroupName);
634           assert(RI != DiagsInGroup.end() && "Referenced without existing?");
635           OS << RI->second.IDNo << ", ";
636         }
637       }
638 
639       OS << "-1,\n";
640     }
641   }
642   OS << "};\n\n";
643 }
644 
645 /// \brief Emit the list of diagnostic arrays.
646 ///
647 /// This data structure is a large array that contains itself arrays of varying
648 /// size. Each array represents a list of diagnostics. The different arrays are
649 /// separated by the value '-1'.
650 ///
651 /// \code
652 ///   static const int16_t DiagArrays[] = {
653 ///     /* Empty */ -1,
654 ///     /* DiagArray1 */ diag::warn_pragma_message,
655 ///                      -1,
656 ///     /* DiagArray2 */ diag::warn_abs_too_small,
657 ///                      diag::warn_unsigned_abs,
658 ///                      diag::warn_wrong_absolute_value_type,
659 ///                      -1
660 ///   };
661 /// \endcode
662 ///
emitDiagArrays(std::map<std::string,GroupInfo> & DiagsInGroup,RecordVec & DiagsInPedantic,raw_ostream & OS)663 static void emitDiagArrays(std::map<std::string, GroupInfo> &DiagsInGroup,
664                            RecordVec &DiagsInPedantic, raw_ostream &OS) {
665   OS << "static const int16_t DiagArrays[] = {\n"
666      << "  /* Empty */ -1,\n";
667   for (auto const &I : DiagsInGroup) {
668     const bool IsPedantic = I.first == "pedantic";
669 
670     const std::vector<const Record *> &V = I.second.DiagsInGroup;
671     if (!V.empty() || (IsPedantic && !DiagsInPedantic.empty())) {
672       OS << "  /* DiagArray" << I.second.IDNo << " */ ";
673       for (auto *Record : V)
674         OS << "diag::" << Record->getName() << ", ";
675       // Emit the diagnostics implicitly in "pedantic".
676       if (IsPedantic) {
677         for (auto const &Diag : DiagsInPedantic)
678           OS << "diag::" << Diag->getName() << ", ";
679       }
680       OS << "-1,\n";
681     }
682   }
683   OS << "};\n\n";
684 }
685 
686 /// \brief Emit a list of group names.
687 ///
688 /// This creates a long string which by itself contains a list of pascal style
689 /// strings, which consist of a length byte directly followed by the string.
690 ///
691 /// \code
692 ///   static const char DiagGroupNames[] = {
693 ///     \000\020#pragma-messages\t#warnings\020CFString-literal"
694 ///   };
695 /// \endcode
emitDiagGroupNames(StringToOffsetTable & GroupNames,raw_ostream & OS)696 static void emitDiagGroupNames(StringToOffsetTable &GroupNames,
697                                raw_ostream &OS) {
698   OS << "static const char DiagGroupNames[] = {\n";
699   GroupNames.EmitString(OS);
700   OS << "};\n\n";
701 }
702 
703 /// \brief Emit diagnostic arrays and related data structures.
704 ///
705 /// This creates the actual diagnostic array, an array of diagnostic subgroups
706 /// and an array of subgroup names.
707 ///
708 /// \code
709 ///  #ifdef GET_DIAG_ARRAYS
710 ///     static const int16_t DiagArrays[];
711 ///     static const int16_t DiagSubGroups[];
712 ///     static const char DiagGroupNames[];
713 ///  #endif
714 ///  \endcode
emitAllDiagArrays(std::map<std::string,GroupInfo> & DiagsInGroup,RecordVec & DiagsInPedantic,RecordVec & GroupsInPedantic,StringToOffsetTable & GroupNames,raw_ostream & OS)715 static void emitAllDiagArrays(std::map<std::string, GroupInfo> &DiagsInGroup,
716                               RecordVec &DiagsInPedantic,
717                               RecordVec &GroupsInPedantic,
718                               StringToOffsetTable &GroupNames,
719                               raw_ostream &OS) {
720   OS << "\n#ifdef GET_DIAG_ARRAYS\n";
721   emitDiagArrays(DiagsInGroup, DiagsInPedantic, OS);
722   emitDiagSubGroups(DiagsInGroup, GroupsInPedantic, OS);
723   emitDiagGroupNames(GroupNames, OS);
724   OS << "#endif // GET_DIAG_ARRAYS\n\n";
725 }
726 
727 /// \brief Emit diagnostic table.
728 ///
729 /// The table is sorted by the name of the diagnostic group. Each element
730 /// consists of the name of the diagnostic group (given as offset in the
731 /// group name table), a reference to a list of diagnostics (optional) and a
732 /// reference to a set of subgroups (optional).
733 ///
734 /// \code
735 /// #ifdef GET_DIAG_TABLE
736 ///  {/* abi */              159, /* DiagArray11 */ 19, /* Empty */          0},
737 ///  {/* aggregate-return */ 180, /* Empty */        0, /* Empty */          0},
738 ///  {/* all */              197, /* Empty */        0, /* DiagSubGroup13 */ 3},
739 ///  {/* deprecated */       1981,/* DiagArray1 */ 348, /* DiagSubGroup3 */  9},
740 /// #endif
741 /// \endcode
emitDiagTable(std::map<std::string,GroupInfo> & DiagsInGroup,RecordVec & DiagsInPedantic,RecordVec & GroupsInPedantic,StringToOffsetTable & GroupNames,raw_ostream & OS)742 static void emitDiagTable(std::map<std::string, GroupInfo> &DiagsInGroup,
743                           RecordVec &DiagsInPedantic,
744                           RecordVec &GroupsInPedantic,
745                           StringToOffsetTable &GroupNames, raw_ostream &OS) {
746   unsigned MaxLen = 0;
747 
748   for (auto const &I: DiagsInGroup)
749     MaxLen = std::max(MaxLen, (unsigned)I.first.size());
750 
751   OS << "\n#ifdef GET_DIAG_TABLE\n";
752   unsigned SubGroupIndex = 1, DiagArrayIndex = 1;
753   for (auto const &I: DiagsInGroup) {
754     // Group option string.
755     OS << "  { /* ";
756     if (I.first.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
757                                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
758                                    "0123456789!@#$%^*-+=:?") !=
759         std::string::npos)
760       PrintFatalError("Invalid character in diagnostic group '" + I.first +
761                       "'");
762     OS << I.first << " */ " << std::string(MaxLen - I.first.size(), ' ');
763     // Store a pascal-style length byte at the beginning of the string.
764     std::string Name = char(I.first.size()) + I.first;
765     OS << GroupNames.GetOrAddStringOffset(Name, false) << ", ";
766 
767     // Special handling for 'pedantic'.
768     const bool IsPedantic = I.first == "pedantic";
769 
770     // Diagnostics in the group.
771     const std::vector<const Record *> &V = I.second.DiagsInGroup;
772     const bool hasDiags =
773         !V.empty() || (IsPedantic && !DiagsInPedantic.empty());
774     if (hasDiags) {
775       OS << "/* DiagArray" << I.second.IDNo << " */ " << DiagArrayIndex
776          << ", ";
777       if (IsPedantic)
778         DiagArrayIndex += DiagsInPedantic.size();
779       DiagArrayIndex += V.size() + 1;
780     } else {
781       OS << "/* Empty */     0, ";
782     }
783 
784     // Subgroups.
785     const std::vector<std::string> &SubGroups = I.second.SubGroups;
786     const bool hasSubGroups =
787         !SubGroups.empty() || (IsPedantic && !GroupsInPedantic.empty());
788     if (hasSubGroups) {
789       OS << "/* DiagSubGroup" << I.second.IDNo << " */ " << SubGroupIndex;
790       if (IsPedantic)
791         SubGroupIndex += GroupsInPedantic.size();
792       SubGroupIndex += SubGroups.size() + 1;
793     } else {
794       OS << "/* Empty */         0";
795     }
796 
797     OS << " },\n";
798   }
799   OS << "#endif // GET_DIAG_TABLE\n\n";
800 }
801 
802 /// \brief Emit the table of diagnostic categories.
803 ///
804 /// The table has the form of macro calls that have two parameters. The
805 /// category's name as well as an enum that represents the category. The
806 /// table can be used by defining the macro 'CATEGORY' and including this
807 /// table right after.
808 ///
809 /// \code
810 /// #ifdef GET_CATEGORY_TABLE
811 ///   CATEGORY("Semantic Issue", DiagCat_Semantic_Issue)
812 ///   CATEGORY("Lambda Issue", DiagCat_Lambda_Issue)
813 /// #endif
814 /// \endcode
emitCategoryTable(RecordKeeper & Records,raw_ostream & OS)815 static void emitCategoryTable(RecordKeeper &Records, raw_ostream &OS) {
816   DiagCategoryIDMap CategoriesByID(Records);
817   OS << "\n#ifdef GET_CATEGORY_TABLE\n";
818   for (auto const &C : CategoriesByID)
819     OS << "CATEGORY(\"" << C << "\", " << getDiagCategoryEnum(C) << ")\n";
820   OS << "#endif // GET_CATEGORY_TABLE\n\n";
821 }
822 
823 namespace clang {
EmitClangDiagGroups(RecordKeeper & Records,raw_ostream & OS)824 void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS) {
825   // Compute a mapping from a DiagGroup to all of its parents.
826   DiagGroupParentMap DGParentMap(Records);
827 
828   std::vector<Record *> Diags = Records.getAllDerivedDefinitions("Diagnostic");
829 
830   std::vector<Record *> DiagGroups =
831       Records.getAllDerivedDefinitions("DiagGroup");
832 
833   std::map<std::string, GroupInfo> DiagsInGroup;
834   groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
835 
836   // All extensions are implicitly in the "pedantic" group.  Record the
837   // implicit set of groups in the "pedantic" group, and use this information
838   // later when emitting the group information for Pedantic.
839   RecordVec DiagsInPedantic;
840   RecordVec GroupsInPedantic;
841   InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
842   inferPedantic.compute(&DiagsInPedantic, &GroupsInPedantic);
843 
844   StringToOffsetTable GroupNames;
845   for (std::map<std::string, GroupInfo>::const_iterator
846            I = DiagsInGroup.begin(),
847            E = DiagsInGroup.end();
848        I != E; ++I) {
849     // Store a pascal-style length byte at the beginning of the string.
850     std::string Name = char(I->first.size()) + I->first;
851     GroupNames.GetOrAddStringOffset(Name, false);
852   }
853 
854   emitAllDiagArrays(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
855                     OS);
856   emitDiagTable(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
857                 OS);
858   emitCategoryTable(Records, OS);
859 }
860 } // end namespace clang
861 
862 //===----------------------------------------------------------------------===//
863 // Diagnostic name index generation
864 //===----------------------------------------------------------------------===//
865 
866 namespace {
867 struct RecordIndexElement
868 {
RecordIndexElement__anon9ee1e1fd0511::RecordIndexElement869   RecordIndexElement() {}
RecordIndexElement__anon9ee1e1fd0511::RecordIndexElement870   explicit RecordIndexElement(Record const &R):
871     Name(R.getName()) {}
872 
873   std::string Name;
874 };
875 } // end anonymous namespace.
876 
877 namespace clang {
EmitClangDiagsIndexName(RecordKeeper & Records,raw_ostream & OS)878 void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
879   const std::vector<Record*> &Diags =
880     Records.getAllDerivedDefinitions("Diagnostic");
881 
882   std::vector<RecordIndexElement> Index;
883   Index.reserve(Diags.size());
884   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
885     const Record &R = *(Diags[i]);
886     Index.push_back(RecordIndexElement(R));
887   }
888 
889   std::sort(Index.begin(), Index.end(),
890             [](const RecordIndexElement &Lhs,
891                const RecordIndexElement &Rhs) { return Lhs.Name < Rhs.Name; });
892 
893   for (unsigned i = 0, e = Index.size(); i != e; ++i) {
894     const RecordIndexElement &R = Index[i];
895 
896     OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
897   }
898 }
899 } // end namespace clang
900