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