utils/TableGen/ClangSACheckersEmitter.cpp

   1 //=- ClangSACheckersEmitter.cpp - Generate Clang SA checkers 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 // This tablegen backend emits Clang Static Analyzer checkers tables.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ClangSACheckersEmitter.h"
  15 #include "Record.h"
  16 #include "llvm/ADT/DenseSet.h"
  17 #include <map>
  18 #include <string>
  19 using namespace llvm;
  20
  21 //===----------------------------------------------------------------------===//
  22 // Static Analyzer Checkers Tables generation
  23 //===----------------------------------------------------------------------===//
  24
  25 /// \brief True if it is specified hidden or a parent package is specified
  26 /// as hidden, otherwise false.
  27 static bool isHidden(const Record &R) {
  28   if (R.getValueAsBit("Hidden"))
  29     return true;
  30   // Not declared as hidden, check the parent package if it is hidden.
  31   if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("ParentPackage")))
  32     return isHidden(*DI->getDef());
  33
  34   return false;
  35 }
  36
  37 static bool isCheckerNamed(const Record *R) {
  38   return !R->getValueAsString("CheckerName").empty();
  39 }
  40
  41 static std::string getPackageFullName(const Record *R);
  42
  43 static std::string getParentPackageFullName(const Record *R) {
  44   std::string name;
  45   if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
  46     name = getPackageFullName(DI->getDef());
  47   return name;
  48 }
  49
  50 static std::string getPackageFullName(const Record *R) {
  51   std::string name = getParentPackageFullName(R);
  52   if (!name.empty()) name += ".";
  53   return name + R->getValueAsString("PackageName");
  54 }
  55
  56 static std::string getCheckerFullName(const Record *R) {
  57   std::string name = getParentPackageFullName(R);
  58   if (isCheckerNamed(R)) {
  59     if (!name.empty()) name += ".";
  60     name += R->getValueAsString("CheckerName");
  61   }
  62   return name;
  63 }
  64
  65 static std::string getStringValue(const Record &R, StringRef field) {
  66   if (StringInit *
  67         SI = dynamic_cast<StringInit*>(R.getValueInit(field)))
  68     return SI->getValue();
  69   return std::string();
  70 }
  71
  72 namespace {
  73 struct GroupInfo {
  74   llvm::DenseSet<const Record*> Checkers;
  75   llvm::DenseSet<const Record *> SubGroups;
  76   bool Hidden;
  77   unsigned Index;
  78
  79   GroupInfo() : Hidden(false) { }
  80 };
  81 }
  82
  83 static void addPackageToCheckerGroup(const Record *package, const Record *group,
  84                   llvm::DenseMap<const Record *, GroupInfo *> &recordGroupMap) {
  85   llvm::DenseSet<const Record *> &checkers = recordGroupMap[package]->Checkers;
  86   for (llvm::DenseSet<const Record *>::iterator
  87          I = checkers.begin(), E = checkers.end(); I != E; ++I)
  88     recordGroupMap[group]->Checkers.insert(*I);
  89
  90   llvm::DenseSet<const Record *> &subGroups = recordGroupMap[package]->SubGroups;
  91   for (llvm::DenseSet<const Record *>::iterator
  92          I = subGroups.begin(), E = subGroups.end(); I != E; ++I)
  93     addPackageToCheckerGroup(*I, group, recordGroupMap);
  94 }
  95
  96 void ClangSACheckersEmitter::run(raw_ostream &OS) {
  97   std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
  98   llvm::DenseMap<const Record *, unsigned> checkerRecIndexMap;
  99   for (unsigned i = 0, e = checkers.size(); i != e; ++i)
 100     checkerRecIndexMap[checkers[i]] = i;
 101
 102   OS << "\n#ifdef GET_CHECKERS\n";
 103   for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
 104     const Record &R = *checkers[i];
 105
 106     OS << "CHECKER(" << "\"";
 107     std::string name;
 108     if (isCheckerNamed(&R))
 109       name = getCheckerFullName(&R);
 110     OS.write_escaped(name) << "\", ";
 111     OS << R.getName() << ", ";
 112     OS << getStringValue(R, "DescFile") << ", ";
 113     OS << "\"";
 114     OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
 115     // Hidden bit
 116     if (isHidden(R))
 117       OS << "true";
 118     else
 119       OS << "false";
 120     OS << ")\n";
 121   }
 122   OS << "#endif // GET_CHECKERS\n\n";
 123
 124   // Invert the mapping of checkers to package/group into a one to many
 125   // mapping of packages/groups to checkers.
 126   std::map<std::string, GroupInfo> groupInfoByName;
 127   llvm::DenseMap<const Record *, GroupInfo *> recordGroupMap;
 128
 129   std::vector<Record*> packages = Records.getAllDerivedDefinitions("Package");
 130   for (unsigned i = 0, e = packages.size(); i != e; ++i) {
 131     Record *R = packages[i];
 132     std::string fullName = getPackageFullName(R);
 133     if (!fullName.empty()) {
 134       GroupInfo &info = groupInfoByName[fullName];
 135       info.Hidden = isHidden(*R);
 136       recordGroupMap[R] = &info;
 137     }
 138   }
 139
 140   std::vector<Record*>
 141       checkerGroups = Records.getAllDerivedDefinitions("CheckerGroup");
 142   for (unsigned i = 0, e = checkerGroups.size(); i != e; ++i) {
 143     Record *R = checkerGroups[i];
 144     std::string name = R->getValueAsString("GroupName");
 145     if (!name.empty()) {
 146       GroupInfo &info = groupInfoByName[name];
 147       recordGroupMap[R] = &info;
 148     }
 149   }
 150
 151   for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
 152     Record *R = checkers[i];
 153     Record *package = 0;
 154     if (DefInit *
 155           DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
 156       package = DI->getDef();
 157     if (!isCheckerNamed(R) && !package)
 158       throw "Checker '" + R->getName() + "' is neither named, nor in a package!";
 159
 160     if (isCheckerNamed(R)) {
 161       // Create a pseudo-group to hold this checker.
 162       std::string fullName = getCheckerFullName(R);
 163       GroupInfo &info = groupInfoByName[fullName];
 164       info.Hidden = R->getValueAsBit("Hidden");
 165       recordGroupMap[R] = &info;
 166       info.Checkers.insert(R);
 167     } else {
 168       recordGroupMap[package]->Checkers.insert(R);
 169     }
 170
 171     Record *currR = isCheckerNamed(R) ? R : package;
 172     // Insert the checker and its parent packages into the subgroups set of
 173     // the corresponding parent package.
 174     while (DefInit *DI
 175              = dynamic_cast<DefInit*>(currR->getValueInit("ParentPackage"))) {
 176       Record *parentPackage = DI->getDef();
 177       recordGroupMap[parentPackage]->SubGroups.insert(currR);
 178       currR = parentPackage;
 179     }
 180     // Insert the checker into the set of its group.
 181     if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group")))
 182       recordGroupMap[DI->getDef()]->Checkers.insert(R);
 183   }
 184
 185   // If a package is in group, add all its checkers and its sub-packages
 186   // checkers into the group.
 187   for (unsigned i = 0, e = packages.size(); i != e; ++i)
 188     if (DefInit *DI = dynamic_cast<DefInit*>(packages[i]->getValueInit("Group")))
 189       addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
 190
 191   unsigned index = 0;
 192   for (std::map<std::string, GroupInfo>::iterator
 193          I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I)
 194     I->second.Index = index++;
 195
 196   // Walk through the packages/groups/checkers emitting an array for each
 197   // set of checkers and an array for each set of subpackages.
 198
 199   OS << "\n#ifdef GET_MEMBER_ARRAYS\n";
 200   unsigned maxLen = 0;
 201   for (std::map<std::string, GroupInfo>::iterator
 202          I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I) {
 203     maxLen = std::max(maxLen, (unsigned)I->first.size());
 204
 205     llvm::DenseSet<const Record *> &checkers = I->second.Checkers;
 206     if (!checkers.empty()) {
 207       OS << "static const short CheckerArray" << I->second.Index << "[] = { ";
 208       for (llvm::DenseSet<const Record *>::iterator
 209           I = checkers.begin(), E = checkers.end(); I != E; ++I)
 210         OS << checkerRecIndexMap[*I] << ", ";
 211       OS << "-1 };\n";
 212     }
 213
 214     llvm::DenseSet<const Record *> &subGroups = I->second.SubGroups;
 215     if (!subGroups.empty()) {
 216       OS << "static const short SubPackageArray" << I->second.Index << "[] = { ";
 217       for (llvm::DenseSet<const Record *>::iterator
 218              I = subGroups.begin(), E = subGroups.end(); I != E; ++I) {
 219         OS << recordGroupMap[*I]->Index << ", ";
 220       }
 221       OS << "-1 };\n";
 222     }
 223   }
 224   OS << "#endif // GET_MEMBER_ARRAYS\n\n";
 225
 226   OS << "\n#ifdef GET_CHECKNAME_TABLE\n";
 227   for (std::map<std::string, GroupInfo>::iterator
 228          I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I) {
 229     // Group option string.
 230     OS << "  { \"";
 231     OS.write_escaped(I->first) << "\","
 232                                << std::string(maxLen-I->first.size()+1, ' ');
 233
 234     if (I->second.Checkers.empty())
 235       OS << "0, ";
 236     else
 237       OS << "CheckerArray" << I->second.Index << ", ";
 238
 239     // Subgroups.
 240     if (I->second.SubGroups.empty())
 241       OS << "0, ";
 242     else
 243       OS << "SubPackageArray" << I->second.Index << ", ";
 244
 245     OS << (I->second.Hidden ? "true" : "false");
 246
 247     OS << " },\n";
 248   }
 249   OS << "#endif // GET_CHECKNAME_TABLE\n\n";
 250 }