utils/TableGen/ClangDiagnosticsEmitter.cpp

   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 "ClangDiagnosticsEmitter.h"
  15 #include "Record.h"
  16 #include "llvm/Support/Debug.h"
  17 #include "llvm/Support/Compiler.h"
  18 #include "llvm/ADT/DenseSet.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/VectorExtras.h"
  22 #include <set>
  23 #include <map>
  24 using namespace llvm;
  25
  26 //===----------------------------------------------------------------------===//
  27 // Diagnostic category computation code.
  28 //===----------------------------------------------------------------------===//
  29
  30 namespace {
  31 class DiagGroupParentMap {
  32   std::map<const Record*, std::vector<Record*> > Mapping;
  33 public:
  34   DiagGroupParentMap() {
  35     std::vector<Record*> DiagGroups
  36       = Records.getAllDerivedDefinitions("DiagGroup");
  37     for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
  38       std::vector<Record*> SubGroups =
  39         DiagGroups[i]->getValueAsListOfDefs("SubGroups");
  40       for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
  41         Mapping[SubGroups[j]].push_back(DiagGroups[i]);
  42     }
  43   }
  44
  45   const std::vector<Record*> &getParents(const Record *Group) {
  46     return Mapping[Group];
  47   }
  48 };
  49 } // end anonymous namespace.
  50
  51
  52 static std::string
  53 getCategoryFromDiagGroup(const Record *Group,
  54                          DiagGroupParentMap &DiagGroupParents) {
  55   // If the DiagGroup has a category, return it.
  56   std::string CatName = Group->getValueAsString("CategoryName");
  57   if (!CatName.empty()) return CatName;
  58
  59   // The diag group may the subgroup of one or more other diagnostic groups,
  60   // check these for a category as well.
  61   const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
  62   for (unsigned i = 0, e = Parents.size(); i != e; ++i) {
  63     CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents);
  64     if (!CatName.empty()) return CatName;
  65   }
  66   return "";
  67 }
  68
  69 /// getDiagnosticCategory - Return the category that the specified diagnostic
  70 /// lives in.
  71 static std::string getDiagnosticCategory(const Record *R,
  72                                          DiagGroupParentMap &DiagGroupParents) {
  73   // If the diagnostic is in a group, and that group has a category, use it.
  74   if (DefInit *Group = dynamic_cast<DefInit*>(R->getValueInit("Group"))) {
  75     // Check the diagnostic's diag group for a category.
  76     std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
  77                                                    DiagGroupParents);
  78     if (!CatName.empty()) return CatName;
  79   }
  80
  81   // If the diagnostic itself has a category, get it.
  82   return R->getValueAsString("CategoryName");
  83 }
  84
  85 namespace {
  86   class DiagCategoryIDMap {
  87     StringMap<unsigned> CategoryIDs;
  88     std::vector<std::string> CategoryStrings;
  89   public:
  90     DiagCategoryIDMap() {
  91       DiagGroupParentMap ParentInfo;
  92
  93       // The zero'th category is "".
  94       CategoryStrings.push_back("");
  95       CategoryIDs[""] = 0;
  96
  97       std::vector<Record*> Diags =
  98       Records.getAllDerivedDefinitions("Diagnostic");
  99       for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
 100         std::string Category = getDiagnosticCategory(Diags[i], ParentInfo);
 101         if (Category.empty()) continue;  // Skip diags with no category.
 102
 103         unsigned &ID = CategoryIDs[Category];
 104         if (ID != 0) continue;  // Already seen.
 105
 106         ID = CategoryStrings.size();
 107         CategoryStrings.push_back(Category);
 108       }
 109     }
 110
 111     unsigned getID(StringRef CategoryString) {
 112       return CategoryIDs[CategoryString];
 113     }
 114
 115     typedef std::vector<std::string>::iterator iterator;
 116     iterator begin() { return CategoryStrings.begin(); }
 117     iterator end() { return CategoryStrings.end(); }
 118   };
 119 } // end anonymous namespace.
 120
 121
 122
 123 //===----------------------------------------------------------------------===//
 124 // Warning Tables (.inc file) generation.
 125 //===----------------------------------------------------------------------===//
 126
 127 void ClangDiagsDefsEmitter::run(raw_ostream &OS) {
 128   // Write the #if guard
 129   if (!Component.empty()) {
 130     std::string ComponentName = UppercaseString(Component);
 131     OS << "#ifdef " << ComponentName << "START\n";
 132     OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName
 133        << ",\n";
 134     OS << "#undef " << ComponentName << "START\n";
 135     OS << "#endif\n\n";
 136   }
 137
 138   const std::vector<Record*> &Diags =
 139     Records.getAllDerivedDefinitions("Diagnostic");
 140
 141   DiagCategoryIDMap CategoryIDs;
 142   DiagGroupParentMap DGParentMap;
 143
 144   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
 145     const Record &R = *Diags[i];
 146     // Filter by component.
 147     if (!Component.empty() && Component != R.getValueAsString("Component"))
 148       continue;
 149
 150     OS << "DIAG(" << R.getName() << ", ";
 151     OS << R.getValueAsDef("Class")->getName();
 152     OS << ", diag::" << R.getValueAsDef("DefaultMapping")->getName();
 153
 154     // Description string.
 155     OS << ", \"";
 156     OS.write_escaped(R.getValueAsString("Text")) << '"';
 157
 158     // Warning associated with the diagnostic.
 159     if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) {
 160       OS << ", \"";
 161       OS.write_escaped(DI->getDef()->getValueAsString("GroupName")) << '"';
 162     } else {
 163       OS << ", 0";
 164     }
 165
 166     // SFINAE bit
 167     if (R.getValueAsBit("SFINAE"))
 168       OS << ", true";
 169     else
 170       OS << ", false";
 171
 172     // Category number.
 173     OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
 174     OS << ")\n";
 175   }
 176 }
 177
 178 //===----------------------------------------------------------------------===//
 179 // Warning Group Tables generation
 180 //===----------------------------------------------------------------------===//
 181
 182 struct GroupInfo {
 183   std::vector<const Record*> DiagsInGroup;
 184   std::vector<std::string> SubGroups;
 185   unsigned IDNo;
 186 };
 187
 188 void ClangDiagGroupsEmitter::run(raw_ostream &OS) {
 189   // Compute a mapping from a DiagGroup to all of its parents.
 190   DiagGroupParentMap DGParentMap;
 191
 192   // Invert the 1-[0/1] mapping of diags to group into a one to many mapping of
 193   // groups to diags in the group.
 194   std::map<std::string, GroupInfo> DiagsInGroup;
 195
 196   std::vector<Record*> Diags =
 197     Records.getAllDerivedDefinitions("Diagnostic");
 198   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
 199     const Record *R = Diags[i];
 200     DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group"));
 201     if (DI == 0) continue;
 202     std::string GroupName = DI->getDef()->getValueAsString("GroupName");
 203     DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
 204   }
 205
 206   // Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty
 207   // groups (these are warnings that GCC supports that clang never produces).
 208   std::vector<Record*> DiagGroups
 209     = Records.getAllDerivedDefinitions("DiagGroup");
 210   for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
 211     Record *Group = DiagGroups[i];
 212     GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
 213
 214     std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
 215     for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
 216       GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
 217   }
 218
 219   // Assign unique ID numbers to the groups.
 220   unsigned IDNo = 0;
 221   for (std::map<std::string, GroupInfo>::iterator
 222        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
 223     I->second.IDNo = IDNo;
 224
 225   // Walk through the groups emitting an array for each diagnostic of the diags
 226   // that are mapped to.
 227   OS << "\n#ifdef GET_DIAG_ARRAYS\n";
 228   unsigned MaxLen = 0;
 229   for (std::map<std::string, GroupInfo>::iterator
 230        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) {
 231     MaxLen = std::max(MaxLen, (unsigned)I->first.size());
 232
 233     std::vector<const Record*> &V = I->second.DiagsInGroup;
 234     if (!V.empty()) {
 235       OS << "static const short DiagArray" << I->second.IDNo << "[] = { ";
 236       for (unsigned i = 0, e = V.size(); i != e; ++i)
 237         OS << "diag::" << V[i]->getName() << ", ";
 238       OS << "-1 };\n";
 239     }
 240
 241     const std::vector<std::string> &SubGroups = I->second.SubGroups;
 242     if (!SubGroups.empty()) {
 243       OS << "static const short DiagSubGroup" << I->second.IDNo << "[] = { ";
 244       for (unsigned i = 0, e = SubGroups.size(); i != e; ++i) {
 245         std::map<std::string, GroupInfo>::iterator RI =
 246           DiagsInGroup.find(SubGroups[i]);
 247         assert(RI != DiagsInGroup.end() && "Referenced without existing?");
 248         OS << RI->second.IDNo << ", ";
 249       }
 250       OS << "-1 };\n";
 251     }
 252   }
 253   OS << "#endif // GET_DIAG_ARRAYS\n\n";
 254
 255   // Emit the table now.
 256   OS << "\n#ifdef GET_DIAG_TABLE\n";
 257   for (std::map<std::string, GroupInfo>::iterator
 258        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) {
 259     // Group option string.
 260     OS << "  { \"";
 261     OS.write_escaped(I->first) << "\","
 262                                << std::string(MaxLen-I->first.size()+1, ' ');
 263
 264     // Diagnostics in the group.
 265     if (I->second.DiagsInGroup.empty())
 266       OS << "0, ";
 267     else
 268       OS << "DiagArray" << I->second.IDNo << ", ";
 269
 270     // Subgroups.
 271     if (I->second.SubGroups.empty())
 272       OS << 0;
 273     else
 274       OS << "DiagSubGroup" << I->second.IDNo;
 275     OS << " },\n";
 276   }
 277   OS << "#endif // GET_DIAG_TABLE\n\n";
 278
 279   // Emit the category table next.
 280   DiagCategoryIDMap CategoriesByID;
 281   OS << "\n#ifdef GET_CATEGORY_TABLE\n";
 282   for (DiagCategoryIDMap::iterator I = CategoriesByID.begin(),
 283        E = CategoriesByID.end(); I != E; ++I)
 284     OS << "CATEGORY(\"" << *I << "\")\n";
 285   OS << "#endif // GET_CATEGORY_TABLE\n\n";
 286 }