utils/TableGen/ClangDiagnosticsEmitter.cpp - platform/external/clang - Gitiles

 //=- ClangDiagnosticsEmitter.cpp - Generate Clang diagnostics tables -*- C++ -*-
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // These tablegen backends emit Clang diagnostics tables.
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <set>
 using namespace llvm;

 //===----------------------------------------------------------------------===//
 // Diagnostic category computation code.
 //===----------------------------------------------------------------------===//

 namespace {
 class DiagGroupParentMap {
   RecordKeeper &Records;
   std::map<const Record*, std::vector<Record*> > Mapping;
 public:
   DiagGroupParentMap(RecordKeeper &records) : Records(records) {
     std::vector<Record*> DiagGroups
       = Records.getAllDerivedDefinitions("DiagGroup");
     for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
       std::vector<Record*> 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<Record*> &getParents(const Record *Group) {
     return Mapping[Group];
   }
 };
 } // end anonymous namespace.

 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;

   // The diag group may the subgroup of one or more other diagnostic groups,
   // check these for a category as well.
   const std::vector<Record*> &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 "";
 }

 /// 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<DefInit*>(R->getValueInit("Group"))) {
     // Check the diagnostic's diag group for a category.
     std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
                                                    DiagGroupParents);
     if (!CatName.empty()) return CatName;
   }

   // If the diagnostic itself has a category, get it.
   return R->getValueAsString("CategoryName");
 }

 namespace {
   class DiagCategoryIDMap {
     RecordKeeper &Records;
     StringMap<unsigned> CategoryIDs;
     std::vector<std::string> CategoryStrings;
   public:
     DiagCategoryIDMap(RecordKeeper &records) : Records(records) {
       DiagGroupParentMap ParentInfo(Records);

       // The zero'th category is "".
       CategoryStrings.push_back("");
       CategoryIDs[""] = 0;

       std::vector<Record*> 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<std::string>::iterator iterator;
     iterator begin() { return CategoryStrings.begin(); }
     iterator end() { return CategoryStrings.end(); }
   };

   struct GroupInfo {
     std::vector<const Record*> DiagsInGroup;
     std::vector<std::string> SubGroups;
     unsigned IDNo;
   };
 } // end anonymous namespace.

 /// \brief Invert the 1-[0/1] mapping of diags to group into a one to many
 /// mapping of groups to diags in the group.
 static void groupDiagnostics(const std::vector<Record*> &Diags,
                              const std::vector<Record*> &DiagGroups,
                              std::map<std::string, GroupInfo> &DiagsInGroup) {
   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     const Record *R = Diags[i];
     DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group"));
     if (DI == 0) continue;
     assert(R->getValueAsDef("Class")->getName() != "CLASS_NOTE" &&
            "Note can't be in a DiagGroup");
     std::string GroupName = DI->getDef()->getValueAsString("GroupName");
     DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
   }

   // 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).
   for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
     Record *Group = DiagGroups[i];
     GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];

     std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
     for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
       GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
   }

   // Assign unique ID numbers to the groups.
   unsigned IDNo = 0;
   for (std::map<std::string, GroupInfo>::iterator
        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
     I->second.IDNo = IDNo;
 }

 //===----------------------------------------------------------------------===//
 // Warning Tables (.inc file) generation.
 //===----------------------------------------------------------------------===//

 /// ClangDiagsDefsEmitter - The top-level class emits .def files containing
 /// declarations of Clang diagnostics.
 namespace clang {
 void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
                         const std::string &Component) {
   // Write the #if guard
   if (!Component.empty()) {
     std::string ComponentName = StringRef(Component).upper();
     OS << "#ifdef " << ComponentName << "START\n";
     OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName
        << ",\n";
     OS << "#undef " << ComponentName << "START\n";
     OS << "#endif\n\n";
   }

   const std::vector<Record*> &Diags =
     Records.getAllDerivedDefinitions("Diagnostic");

   std::vector<Record*> DiagGroups
     = Records.getAllDerivedDefinitions("DiagGroup");

   std::map<std::string, GroupInfo> DiagsInGroup;
   groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

   DiagCategoryIDMap CategoryIDs(Records);
   DiagGroupParentMap DGParentMap(Records);

   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. This is stored as an index into
     // the alphabetically sorted warning table.
     if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) {
       std::map<std::string, GroupInfo>::iterator I =
           DiagsInGroup.find(DI->getDef()->getValueAsString("GroupName"));
       assert(I != DiagsInGroup.end());
       OS << ", " << I->second.IDNo;
     } else {
       OS << ", 0";
     }

     // SFINAE bit
     if (R.getValueAsBit("SFINAE"))
       OS << ", true";
     else
       OS << ", false";

     // Access control bit
     if (R.getValueAsBit("AccessControl"))
       OS << ", true";
     else
       OS << ", false";

     // FIXME: This condition is just to avoid temporary revlock, it can be
     // removed.
     if (R.getValue("WarningNoWerror")) {
       // Default warning has no Werror bit.
       if (R.getValueAsBit("WarningNoWerror"))
         OS << ", true";
       else
         OS << ", false";

       // Default warning show in system header bit.
       if (R.getValueAsBit("WarningShowInSystemHeader"))
         OS << ", true";
       else
         OS << ", false";
     }

     // Category number.
     OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
     OS << ")\n";
   }
 }
 } // end namespace clang

 //===----------------------------------------------------------------------===//
 // Warning Group Tables generation
 //===----------------------------------------------------------------------===//

 static std::string getDiagCategoryEnum(llvm::StringRef name) {
   if (name.empty())
     return "DiagCat_None";
   SmallString<256> enumName = llvm::StringRef("DiagCat_");
   for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
     enumName += isalnum(*I) ? *I : '_';
   return enumName.str();
 }

 namespace clang {
 void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS) {
   // Compute a mapping from a DiagGroup to all of its parents.
   DiagGroupParentMap DGParentMap(Records);

   std::vector<Record*> Diags =
     Records.getAllDerivedDefinitions("Diagnostic");

   std::vector<Record*> DiagGroups
     = Records.getAllDerivedDefinitions("DiagGroup");

   std::map<std::string, GroupInfo> DiagsInGroup;
   groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

   // 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<std::string, GroupInfo>::iterator
        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) {
     MaxLen = std::max(MaxLen, (unsigned)I->first.size());

     std::vector<const Record*> &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<std::string> &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<std::string, GroupInfo>::iterator RI =
           DiagsInGroup.find(SubGroups[i]);
         assert(RI != DiagsInGroup.end() && "Referenced without existing?");
         OS << RI->second.IDNo << ", ";
       }
       OS << "-1 };\n";
     }
   }
   OS << "#endif // GET_DIAG_ARRAYS\n\n";

   // Emit the table now.
   OS << "\n#ifdef GET_DIAG_TABLE\n";
   for (std::map<std::string, GroupInfo>::iterator
        I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) {
     // Group option string.
     OS << "  { ";
     OS << I->first.size() << ", ";
     OS << "\"";
     if (I->first.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
                                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                    "0123456789!@#$%^*-+=:?")!=std::string::npos)
       throw "Invalid character in diagnostic group '" + I->first + "'";
     OS.write_escaped(I->first) << "\","
                                << std::string(MaxLen-I->first.size()+1, ' ');

     // Diagnostics in the group.
     if (I->second.DiagsInGroup.empty())
       OS << "0, ";
     else
       OS << "DiagArray" << I->second.IDNo << ", ";

     // Subgroups.
     if (I->second.SubGroups.empty())
       OS << 0;
     else
       OS << "DiagSubGroup" << I->second.IDNo;
     OS << " },\n";
   }
   OS << "#endif // GET_DIAG_TABLE\n\n";

   // Emit the category table next.
   DiagCategoryIDMap CategoriesByID(Records);
   OS << "\n#ifdef GET_CATEGORY_TABLE\n";
   for (DiagCategoryIDMap::iterator I = CategoriesByID.begin(),
        E = CategoriesByID.end(); I != E; ++I)
     OS << "CATEGORY(\"" << *I << "\", " << getDiagCategoryEnum(*I) << ")\n";
   OS << "#endif // GET_CATEGORY_TABLE\n\n";
 }
 } // end namespace clang

 //===----------------------------------------------------------------------===//
 // Diagnostic name index generation
 //===----------------------------------------------------------------------===//

 namespace {
 struct RecordIndexElement
 {
   RecordIndexElement() {}
   explicit RecordIndexElement(Record const &R):
     Name(R.getName()) {}

   std::string Name;
 };

 struct RecordIndexElementSorter :
   public std::binary_function<RecordIndexElement, RecordIndexElement, bool> {

   bool operator()(RecordIndexElement const &Lhs,
                   RecordIndexElement const &Rhs) const {
     return Lhs.Name < Rhs.Name;
   }

 };

 } // end anonymous namespace.

 namespace clang {
 void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
   const std::vector<Record*> &Diags =
     Records.getAllDerivedDefinitions("Diagnostic");

   std::vector<RecordIndexElement> Index;
   Index.reserve(Diags.size());
   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     const Record &R = *(Diags[i]);
     Index.push_back(RecordIndexElement(R));
   }

   std::sort(Index.begin(), Index.end(), RecordIndexElementSorter());

   for (unsigned i = 0, e = Index.size(); i != e; ++i) {
     const RecordIndexElement &R = Index[i];

     OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
   }
 }
 } // end namespace clang
	//=- ClangDiagnosticsEmitter.cpp - Generate Clang diagnostics tables -- C++ --
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	//
	// These tablegen backends emit Clang diagnostics tables.
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/ADT/DenseSet.h"
	#include "llvm/ADT/SmallString.h"
	#include "llvm/ADT/StringMap.h"
	#include "llvm/Support/Compiler.h"
	#include "llvm/Support/Debug.h"
	#include "llvm/TableGen/Record.h"
	#include "llvm/TableGen/TableGenBackend.h"
	#include <algorithm>
	#include <functional>
	#include <map>
	#include <set>
	using namespace llvm;

	//===----------------------------------------------------------------------===//
	// Diagnostic category computation code.
	//===----------------------------------------------------------------------===//

	namespace {
	class DiagGroupParentMap {
	RecordKeeper &Records;
	std::map<const Record, std::vector<Record> > Mapping;
	public:
	DiagGroupParentMap(RecordKeeper &records) : Records(records) {
	std::vector<Record*> DiagGroups
	= Records.getAllDerivedDefinitions("DiagGroup");
	for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
	std::vector<Record*> 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<Record> &getParents(const Record Group) {
	return Mapping[Group];
	}
	};
	} // end anonymous namespace.

	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;

	// The diag group may the subgroup of one or more other diagnostic groups,
	// check these for a category as well.
	const std::vector<Record*> &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 "";
	}

	/// 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<DefInit>(R->getValueInit("Group"))) {
	// Check the diagnostic's diag group for a category.
	std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
	DiagGroupParents);
	if (!CatName.empty()) return CatName;
	}

	// If the diagnostic itself has a category, get it.
	return R->getValueAsString("CategoryName");
	}

	namespace {
	class DiagCategoryIDMap {
	RecordKeeper &Records;
	StringMap<unsigned> CategoryIDs;
	std::vector<std::string> CategoryStrings;
	public:
	DiagCategoryIDMap(RecordKeeper &records) : Records(records) {
	DiagGroupParentMap ParentInfo(Records);

	// The zero'th category is "".
	CategoryStrings.push_back("");
	CategoryIDs[""] = 0;

	std::vector<Record*> 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<std::string>::iterator iterator;
	iterator begin() { return CategoryStrings.begin(); }
	iterator end() { return CategoryStrings.end(); }
	};

	struct GroupInfo {
	std::vector<const Record*> DiagsInGroup;
	std::vector<std::string> SubGroups;
	unsigned IDNo;
	};
	} // end anonymous namespace.

	/// \brief Invert the 1-[0/1] mapping of diags to group into a one to many
	/// mapping of groups to diags in the group.
	static void groupDiagnostics(const std::vector<Record*> &Diags,
	const std::vector<Record*> &DiagGroups,
	std::map<std::string, GroupInfo> &DiagsInGroup) {
	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
	const Record *R = Diags[i];
	DefInit DI = dynamic_cast<DefInit>(R->getValueInit("Group"));
	if (DI == 0) continue;
	assert(R->getValueAsDef("Class")->getName() != "CLASS_NOTE" &&
	"Note can't be in a DiagGroup");
	std::string GroupName = DI->getDef()->getValueAsString("GroupName");
	DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
	}

	// 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).
	for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
	Record *Group = DiagGroups[i];
	GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];

	std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
	for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
	GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
	}

	// Assign unique ID numbers to the groups.
	unsigned IDNo = 0;
	for (std::map<std::string, GroupInfo>::iterator
	I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
	I->second.IDNo = IDNo;
	}

	//===----------------------------------------------------------------------===//
	// Warning Tables (.inc file) generation.
	//===----------------------------------------------------------------------===//

	/// ClangDiagsDefsEmitter - The top-level class emits .def files containing
	/// declarations of Clang diagnostics.
	namespace clang {
	void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
	const std::string &Component) {
	// Write the #if guard
	if (!Component.empty()) {
	std::string ComponentName = StringRef(Component).upper();
	OS << "#ifdef " << ComponentName << "START\n";
	OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName
	<< ",\n";
	OS << "#undef " << ComponentName << "START\n";
	OS << "#endif\n\n";
	}

	const std::vector<Record*> &Diags =
	Records.getAllDerivedDefinitions("Diagnostic");

	std::vector<Record*> DiagGroups
	= Records.getAllDerivedDefinitions("DiagGroup");

	std::map<std::string, GroupInfo> DiagsInGroup;
	groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

	DiagCategoryIDMap CategoryIDs(Records);
	DiagGroupParentMap DGParentMap(Records);

	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. This is stored as an index into
	// the alphabetically sorted warning table.
	if (DefInit DI = dynamic_cast<DefInit>(R.getValueInit("Group"))) {
	std::map<std::string, GroupInfo>::iterator I =
	DiagsInGroup.find(DI->getDef()->getValueAsString("GroupName"));
	assert(I != DiagsInGroup.end());
	OS << ", " << I->second.IDNo;
	} else {
	OS << ", 0";
	}

	// SFINAE bit
	if (R.getValueAsBit("SFINAE"))
	OS << ", true";
	else
	OS << ", false";

	// Access control bit
	if (R.getValueAsBit("AccessControl"))
	OS << ", true";
	else
	OS << ", false";

	// FIXME: This condition is just to avoid temporary revlock, it can be
	// removed.
	if (R.getValue("WarningNoWerror")) {
	// Default warning has no Werror bit.
	if (R.getValueAsBit("WarningNoWerror"))
	OS << ", true";
	else
	OS << ", false";

	// Default warning show in system header bit.
	if (R.getValueAsBit("WarningShowInSystemHeader"))
	OS << ", true";
	else
	OS << ", false";
	}

	// Category number.
	OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
	OS << ")\n";
	}
	}
	} // end namespace clang

	//===----------------------------------------------------------------------===//
	// Warning Group Tables generation
	//===----------------------------------------------------------------------===//

	static std::string getDiagCategoryEnum(llvm::StringRef name) {
	if (name.empty())
	return "DiagCat_None";
	SmallString<256> enumName = llvm::StringRef("DiagCat_");
	for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
	enumName += isalnum(I) ? I : '_';
	return enumName.str();
	}

	namespace clang {
	void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS) {
	// Compute a mapping from a DiagGroup to all of its parents.
	DiagGroupParentMap DGParentMap(Records);

	std::vector<Record*> Diags =
	Records.getAllDerivedDefinitions("Diagnostic");

	std::vector<Record*> DiagGroups
	= Records.getAllDerivedDefinitions("DiagGroup");

	std::map<std::string, GroupInfo> DiagsInGroup;
	groupDiagnostics(Diags, DiagGroups, DiagsInGroup);

	// 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<std::string, GroupInfo>::iterator
	I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) {
	MaxLen = std::max(MaxLen, (unsigned)I->first.size());

	std::vector<const Record*> &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<std::string> &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<std::string, GroupInfo>::iterator RI =
	DiagsInGroup.find(SubGroups[i]);
	assert(RI != DiagsInGroup.end() && "Referenced without existing?");
	OS << RI->second.IDNo << ", ";
	}
	OS << "-1 };\n";
	}
	}
	OS << "#endif // GET_DIAG_ARRAYS\n\n";

	// Emit the table now.
	OS << "\n#ifdef GET_DIAG_TABLE\n";
	for (std::map<std::string, GroupInfo>::iterator
	I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I) {
	// Group option string.
	OS << " { ";
	OS << I->first.size() << ", ";
	OS << "\"";
	if (I->first.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"0123456789!@#$%^*-+=:?")!=std::string::npos)
	throw "Invalid character in diagnostic group '" + I->first + "'";
	OS.write_escaped(I->first) << "\","
	<< std::string(MaxLen-I->first.size()+1, ' ');

	// Diagnostics in the group.
	if (I->second.DiagsInGroup.empty())
	OS << "0, ";
	else
	OS << "DiagArray" << I->second.IDNo << ", ";

	// Subgroups.
	if (I->second.SubGroups.empty())
	OS << 0;
	else
	OS << "DiagSubGroup" << I->second.IDNo;
	OS << " },\n";
	}
	OS << "#endif // GET_DIAG_TABLE\n\n";

	// Emit the category table next.
	DiagCategoryIDMap CategoriesByID(Records);
	OS << "\n#ifdef GET_CATEGORY_TABLE\n";
	for (DiagCategoryIDMap::iterator I = CategoriesByID.begin(),
	E = CategoriesByID.end(); I != E; ++I)
	OS << "CATEGORY(\"" << I << "\", " << getDiagCategoryEnum(I) << ")\n";
	OS << "#endif // GET_CATEGORY_TABLE\n\n";
	}
	} // end namespace clang

	//===----------------------------------------------------------------------===//
	// Diagnostic name index generation
	//===----------------------------------------------------------------------===//

	namespace {
	struct RecordIndexElement
	{
	RecordIndexElement() {}
	explicit RecordIndexElement(Record const &R):
	Name(R.getName()) {}

	std::string Name;
	};

	struct RecordIndexElementSorter :
	public std::binary_function<RecordIndexElement, RecordIndexElement, bool> {

	bool operator()(RecordIndexElement const &Lhs,
	RecordIndexElement const &Rhs) const {
	return Lhs.Name < Rhs.Name;
	}

	};

	} // end anonymous namespace.

	namespace clang {
	void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
	const std::vector<Record*> &Diags =
	Records.getAllDerivedDefinitions("Diagnostic");

	std::vector<RecordIndexElement> Index;
	Index.reserve(Diags.size());
	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
	const Record &R = *(Diags[i]);
	Index.push_back(RecordIndexElement(R));
	}

	std::sort(Index.begin(), Index.end(), RecordIndexElementSorter());

	for (unsigned i = 0, e = Index.size(); i != e; ++i) {
	const RecordIndexElement &R = Index[i];

	OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
	}
	}
	} // end namespace clang