X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=utils%2FTableGen%2FClangDiagnosticsEmitter.cpp;h=75b6252c4f9f70961d40bbab9b4c3033c903ff0e;hb=e86b01c153ba52307ecb6e7513ec33f57caedfdd;hp=3d353518e204b9f0a6f48db3de262d27574aee11;hpb=da4231f134989af7dc6bd3408821ba573def27b2;p=oota-llvm.git diff --git a/utils/TableGen/ClangDiagnosticsEmitter.cpp b/utils/TableGen/ClangDiagnosticsEmitter.cpp index 3d353518e20..75b6252c4f9 100644 --- a/utils/TableGen/ClangDiagnosticsEmitter.cpp +++ b/utils/TableGen/ClangDiagnosticsEmitter.cpp @@ -15,222 +15,272 @@ #include "Record.h" #include "llvm/Support/Debug.h" #include "llvm/Support/Compiler.h" -#include "llvm/Support/Streams.h" -#include "llvm/ADT/VectorExtras.h" #include "llvm/ADT/DenseSet.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/ADT/VectorExtras.h" #include #include - using namespace llvm; //===----------------------------------------------------------------------===// -// Generic routines for all Clang TableGen backends. +// Diagnostic category computation code. //===----------------------------------------------------------------------===// -typedef std::vector RecordVector; -typedef std::vector SuperClassVector; -typedef std::vector RecordValVector; +namespace { +class DiagGroupParentMap { + std::map > Mapping; +public: + DiagGroupParentMap() { + std::vector DiagGroups + = Records.getAllDerivedDefinitions("DiagGroup"); + for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) { + std::vector SubGroups = + DiagGroups[i]->getValueAsListOfDefs("SubGroups"); + for (unsigned j = 0, e = SubGroups.size(); j != e; ++j) + Mapping[SubGroups[j]].push_back(DiagGroups[i]); + } + } + + const std::vector &getParents(const Record *Group) { + return Mapping[Group]; + } +}; +} // end anonymous namespace. + -static const RecordVal* findRecordVal(const Record& R, const std::string &key) { - const RecordValVector &Vals = R.getValues(); - for (RecordValVector::const_iterator I=Vals.begin(), E=Vals.end(); I!=E; ++I) - if ((*I).getName() == key) - return &*I; +static std::string +getCategoryFromDiagGroup(const Record *Group, + DiagGroupParentMap &DiagGroupParents) { + // If the DiagGroup has a category, return it. + std::string CatName = Group->getValueAsString("CategoryName"); + if (!CatName.empty()) return CatName; - return 0; + // The diag group may the subgroup of one or more other diagnostic groups, + // check these for a category as well. + const std::vector &Parents = DiagGroupParents.getParents(Group); + for (unsigned i = 0, e = Parents.size(); i != e; ++i) { + CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents); + if (!CatName.empty()) return CatName; + } + return ""; } -static const Record* getDiagKind(const Record* DiagClass, const Record &R) { - const SuperClassVector &SC = R.getSuperClasses(); - for (SuperClassVector::const_iterator I=SC.begin(), E=SC.end(); I!=E; ++I) - if ((*I)->isSubClassOf(DiagClass) && - (*I)->getName() != "DiagnosticControlled") - return *I; +/// getDiagnosticCategory - Return the category that the specified diagnostic +/// lives in. +static std::string getDiagnosticCategory(const Record *R, + DiagGroupParentMap &DiagGroupParents) { + // If the diagnostic is in a group, and that group has a category, use it. + if (DefInit *Group = dynamic_cast(R->getValueInit("Group"))) { + // Check the diagnostic's diag group for a category. + std::string CatName = getCategoryFromDiagGroup(Group->getDef(), + DiagGroupParents); + if (!CatName.empty()) return CatName; + } - return 0; + // If the diagnostic itself has a category, get it. + return R->getValueAsString("CategoryName"); } -static void EmitEscaped(std::ostream& OS, const std::string &s) { - for (std::string::const_iterator I=s.begin(), E=s.end(); I!=E; ++I) - switch (*I) { - default: OS << *I; break; - case '\"': OS << "\\" << *I; break; - case '\\': OS << "\\\\"; break; +namespace { + class DiagCategoryIDMap { + StringMap CategoryIDs; + std::vector CategoryStrings; + public: + DiagCategoryIDMap() { + DiagGroupParentMap ParentInfo; + + // The zero'th category is "". + CategoryStrings.push_back(""); + CategoryIDs[""] = 0; + + std::vector Diags = + Records.getAllDerivedDefinitions("Diagnostic"); + for (unsigned i = 0, e = Diags.size(); i != e; ++i) { + std::string Category = getDiagnosticCategory(Diags[i], ParentInfo); + if (Category.empty()) continue; // Skip diags with no category. + + unsigned &ID = CategoryIDs[Category]; + if (ID != 0) continue; // Already seen. + + ID = CategoryStrings.size(); + CategoryStrings.push_back(Category); + } } -} + + unsigned getID(StringRef CategoryString) { + return CategoryIDs[CategoryString]; + } + + typedef std::vector::iterator iterator; + iterator begin() { return CategoryStrings.begin(); } + iterator end() { return CategoryStrings.end(); } + }; +} // end anonymous namespace. + -static void EmitAllCaps(std::ostream& OS, const std::string &s) { - for (std::string::const_iterator I=s.begin(), E=s.end(); I!=E; ++I) - OS << char(toupper(*I)); -} //===----------------------------------------------------------------------===// // Warning Tables (.inc file) generation. //===----------------------------------------------------------------------===// -static void ProcessDiag(std::ostream& OS, const Record* DiagClass, - const Record& R) { - - const Record* DiagKind = getDiagKind(DiagClass, R); - if (!DiagKind) - return; - - OS << "DIAG(" << R.getName() << ", "; - EmitAllCaps(OS, DiagKind->getName()); - - const RecordVal* Text = findRecordVal(R, "Text"); - assert(Text && "No 'Text' entry in Diagnostic."); - const StringInit* TextVal = dynamic_cast(Text->getValue()); - assert(TextVal && "Value 'Text' must be a string."); - OS << ", \""; - EmitEscaped(OS, TextVal->getValue()); - OS << "\")\n"; -} - -void ClangDiagsDefsEmitter::run(std::ostream &OS) { - const RecordVector &Diags = Records.getAllDerivedDefinitions("Diagnostic"); - - const Record* DiagClass = Records.getClass("Diagnostic"); - assert(DiagClass && "No Diagnostic class defined."); - +void ClangDiagsDefsEmitter::run(raw_ostream &OS) { // Write the #if guard if (!Component.empty()) { - OS << "#ifdef "; - EmitAllCaps(OS, Component); - OS << "START\n__"; - EmitAllCaps(OS, Component); - OS << "START = DIAG_START_"; - EmitAllCaps(OS, Component); - OS << ",\n#undef "; - EmitAllCaps(OS, Component); - OS << "START\n#endif\n"; + std::string ComponentName = UppercaseString(Component); + OS << "#ifdef " << ComponentName << "START\n"; + OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName + << ",\n"; + OS << "#undef " << ComponentName << "START\n"; + OS << "#endif\n\n"; } + + const std::vector &Diags = + Records.getAllDerivedDefinitions("Diagnostic"); - for (RecordVector::const_iterator I=Diags.begin(), E=Diags.end(); I!=E; ++I) { - if (!Component.empty()) { - const RecordVal* V = findRecordVal(**I, "Component"); - if (!V) - continue; - - const StringInit* SV = dynamic_cast(V->getValue()); - if (!SV || SV->getValue() != Component) - continue; + DiagCategoryIDMap CategoryIDs; + DiagGroupParentMap DGParentMap; + + for (unsigned i = 0, e = Diags.size(); i != e; ++i) { + const Record &R = *Diags[i]; + // Filter by component. + if (!Component.empty() && Component != R.getValueAsString("Component")) + continue; + + OS << "DIAG(" << R.getName() << ", "; + OS << R.getValueAsDef("Class")->getName(); + OS << ", diag::" << R.getValueAsDef("DefaultMapping")->getName(); + + // Description string. + OS << ", \""; + OS.write_escaped(R.getValueAsString("Text")) << '"'; + + // Warning associated with the diagnostic. + if (DefInit *DI = dynamic_cast(R.getValueInit("Group"))) { + OS << ", \""; + OS.write_escaped(DI->getDef()->getValueAsString("GroupName")) << '"'; + } else { + OS << ", 0"; } + + // SFINAE bit + if (R.getValueAsBit("SFINAE")) + OS << ", true"; + else + OS << ", false"; - ProcessDiag(OS, DiagClass, **I); + // Category number. + OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap)); + OS << ")\n"; } } //===----------------------------------------------------------------------===// -// Warning Group Tables generation. +// Warning Group Tables generation //===----------------------------------------------------------------------===// -static const std::string &getOptName(const Record *R) { - const RecordVal *V = findRecordVal(*R, "Name"); - assert(V && "Options must have a 'Name' value."); - const StringInit* SV = dynamic_cast(V->getValue()); - assert(SV && "'Name' entry must be a string."); - return SV->getValue(); -} - -namespace { -struct VISIBILITY_HIDDEN CompareOptName { - bool operator()(const Record* A, const Record* B) { - return getOptName(A) < getOptName(B); - } +struct GroupInfo { + std::vector DiagsInGroup; + std::vector SubGroups; + unsigned IDNo; }; -} -typedef std::set DiagnosticSet; -typedef std::map OptionMap; -typedef llvm::DenseSet VisitedLists; - -static void BuildGroup(DiagnosticSet& DS, VisitedLists &Visited, const Init* X); - -static void BuildGroup(DiagnosticSet &DS, VisitedLists &Visited, - const ListInit* LV) { - - // Simple hack to prevent including a list multiple times. This may be useful - // if one declares an Option by including a bunch of other Options that - // include other Options, etc. - if (Visited.count(LV)) - return; +void ClangDiagGroupsEmitter::run(raw_ostream &OS) { + // Compute a mapping from a DiagGroup to all of its parents. + DiagGroupParentMap DGParentMap; - Visited.insert(LV); + // Invert the 1-[0/1] mapping of diags to group into a one to many mapping of + // groups to diags in the group. + std::map DiagsInGroup; - // Iterate through the list and grab all DiagnosticControlled. - for (ListInit::const_iterator I = LV->begin(), E = LV->end(); I!=E; ++I) - BuildGroup(DS, Visited, *I); -} - -static void BuildGroup(DiagnosticSet& DS, VisitedLists &Visited, - const Record *Def) { - - // If an Option includes another Option, inline the Diagnostics of the - // included Option. - if (Def->isSubClassOf("Option")) { - if (const RecordVal* V = findRecordVal(*Def, "Members")) - if (const ListInit* LV = dynamic_cast(V->getValue())) - BuildGroup(DS, Visited, LV); - - return; + std::vector Diags = + Records.getAllDerivedDefinitions("Diagnostic"); + for (unsigned i = 0, e = Diags.size(); i != e; ++i) { + const Record *R = Diags[i]; + DefInit *DI = dynamic_cast(R->getValueInit("Group")); + if (DI == 0) continue; + std::string GroupName = DI->getDef()->getValueAsString("GroupName"); + DiagsInGroup[GroupName].DiagsInGroup.push_back(R); } - if (Def->isSubClassOf("DiagnosticControlled")) - DS.insert(Def); -} - -static void BuildGroup(DiagnosticSet& DS, VisitedLists &Visited, - const Init* X) { - - if (const DefInit *D = dynamic_cast(X)) - BuildGroup(DS, Visited, D->getDef()); + // Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty + // groups (these are warnings that GCC supports that clang never produces). + std::vector DiagGroups + = Records.getAllDerivedDefinitions("DiagGroup"); + for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) { + Record *Group = DiagGroups[i]; + GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")]; + + std::vector SubGroups = Group->getValueAsListOfDefs("SubGroups"); + for (unsigned j = 0, e = SubGroups.size(); j != e; ++j) + GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName")); + } - // We may have some other cases here in the future. -} - - -void ClangOptionsEmitter::run(std::ostream &OS) { - // Build up a map from options to controlled diagnostics. - OptionMap OM; - - const RecordVector &Opts = Records.getAllDerivedDefinitions("Option"); - for (RecordVector::const_iterator I=Opts.begin(), E=Opts.end(); I!=E; ++I) - if (const RecordVal* V = findRecordVal(**I, "Members")) - if (const ListInit* LV = dynamic_cast(V->getValue())) { - VisitedLists Visited; - BuildGroup(OM[*I], Visited, LV); - } + // Assign unique ID numbers to the groups. + unsigned IDNo = 0; + for (std::map::iterator + I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo) + I->second.IDNo = IDNo; - // Iterate through the OptionMap and emit the declarations. - for (OptionMap::iterator I = OM.begin(), E = OM.end(); I!=E; ++I) { - // Output the option. - OS << "static const diag::kind " << I->first->getName() << "[] = { "; + // Walk through the groups emitting an array for each diagnostic of the diags + // that are mapped to. + OS << "\n#ifdef GET_DIAG_ARRAYS\n"; + unsigned MaxLen = 0; + for (std::map::iterator + I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) { + MaxLen = std::max(MaxLen, (unsigned)I->first.size()); - DiagnosticSet &DS = I->second; - bool first = true; - for (DiagnosticSet::iterator I2 = DS.begin(), E2 = DS.end(); I2!=E2; ++I2) { - if (first) - first = false; - else - OS << ", "; - - OS << "diag::" << (*I2)->getName(); + std::vector &V = I->second.DiagsInGroup; + if (!V.empty()) { + OS << "static const short DiagArray" << I->second.IDNo << "[] = { "; + for (unsigned i = 0, e = V.size(); i != e; ++i) + OS << "diag::" << V[i]->getName() << ", "; + OS << "-1 };\n"; + } + + const std::vector &SubGroups = I->second.SubGroups; + if (!SubGroups.empty()) { + OS << "static const short DiagSubGroup" << I->second.IDNo << "[] = { "; + for (unsigned i = 0, e = SubGroups.size(); i != e; ++i) { + std::map::iterator RI = + DiagsInGroup.find(SubGroups[i]); + assert(RI != DiagsInGroup.end() && "Referenced without existing?"); + OS << RI->second.IDNo << ", "; + } + OS << "-1 };\n"; } - OS << " };\n"; } + OS << "#endif // GET_DIAG_ARRAYS\n\n"; + + // Emit the table now. + OS << "\n#ifdef GET_DIAG_TABLE\n"; + for (std::map::iterator + I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) { + // Group option string. + OS << " { \""; + OS.write_escaped(I->first) << "\"," + << std::string(MaxLen-I->first.size()+1, ' '); - // Now emit the OptionTable table. - OS << "\nstatic const WarningOption OptionTable[] = {"; - bool first = true; - for (OptionMap::iterator I = OM.begin(), E = OM.end(); I!=E; ++I) { - if (first) - first = false; + // Diagnostics in the group. + if (I->second.DiagsInGroup.empty()) + OS << "0, "; else - OS << ','; + OS << "DiagArray" << I->second.IDNo << ", "; - OS << "\n {\"" << getOptName(I->first) - << "\", DIAGS(" << I->first->getName() << ")}"; + // Subgroups. + if (I->second.SubGroups.empty()) + OS << 0; + else + OS << "DiagSubGroup" << I->second.IDNo; + OS << " },\n"; } - OS << "\n};\n"; + OS << "#endif // GET_DIAG_TABLE\n\n"; + + // Emit the category table next. + DiagCategoryIDMap CategoriesByID; + OS << "\n#ifdef GET_CATEGORY_TABLE\n"; + for (DiagCategoryIDMap::iterator I = CategoriesByID.begin(), + E = CategoriesByID.end(); I != E; ++I) + OS << "CATEGORY(\"" << *I << "\")\n"; + OS << "#endif // GET_CATEGORY_TABLE\n\n"; }