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 "llvm/ADT/DenseSet.h"
15#include "llvm/TableGen/Error.h"
16#include "llvm/TableGen/Record.h"
17#include "llvm/TableGen/TableGenBackend.h"
18#include <map>
19#include <string>
20using namespace llvm;
21
22//===----------------------------------------------------------------------===//
23// Static Analyzer Checkers Tables generation
24//===----------------------------------------------------------------------===//
25
26/// \brief True if it is specified hidden or a parent package is specified
27/// as hidden, otherwise false.
28static bool isHidden(const Record &R) {
29  if (R.getValueAsBit("Hidden"))
30    return true;
31  // Not declared as hidden, check the parent package if it is hidden.
32  if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("ParentPackage")))
33    return isHidden(*DI->getDef());
34
35  return false;
36}
37
38static bool isCheckerNamed(const Record *R) {
39  return !R->getValueAsString("CheckerName").empty();
40}
41
42static std::string getPackageFullName(const Record *R);
43
44static std::string getParentPackageFullName(const Record *R) {
45  std::string name;
46  if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("ParentPackage")))
47    name = getPackageFullName(DI->getDef());
48  return name;
49}
50
51static std::string getPackageFullName(const Record *R) {
52  std::string name = getParentPackageFullName(R);
53  if (!name.empty()) name += ".";
54  return name + R->getValueAsString("PackageName");
55}
56
57static std::string getCheckerFullName(const Record *R) {
58  std::string name = getParentPackageFullName(R);
59  if (isCheckerNamed(R)) {
60    if (!name.empty()) name += ".";
61    name += R->getValueAsString("CheckerName");
62  }
63  return name;
64}
65
66static std::string getStringValue(const Record &R, StringRef field) {
67  if (StringInit *SI = dyn_cast<StringInit>(R.getValueInit(field)))
68    return SI->getValue();
69  return std::string();
70}
71
72namespace {
73struct 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
83static 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
96namespace clang {
97void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
98  std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
99  llvm::DenseMap<const Record *, unsigned> checkerRecIndexMap;
100  for (unsigned i = 0, e = checkers.size(); i != e; ++i)
101    checkerRecIndexMap[checkers[i]] = i;
102
103  // Invert the mapping of checkers to package/group into a one to many
104  // mapping of packages/groups to checkers.
105  std::map<std::string, GroupInfo> groupInfoByName;
106  llvm::DenseMap<const Record *, GroupInfo *> recordGroupMap;
107
108  std::vector<Record*> packages = Records.getAllDerivedDefinitions("Package");
109  for (unsigned i = 0, e = packages.size(); i != e; ++i) {
110    Record *R = packages[i];
111    std::string fullName = getPackageFullName(R);
112    if (!fullName.empty()) {
113      GroupInfo &info = groupInfoByName[fullName];
114      info.Hidden = isHidden(*R);
115      recordGroupMap[R] = &info;
116    }
117  }
118
119  std::vector<Record*>
120      checkerGroups = Records.getAllDerivedDefinitions("CheckerGroup");
121  for (unsigned i = 0, e = checkerGroups.size(); i != e; ++i) {
122    Record *R = checkerGroups[i];
123    std::string name = R->getValueAsString("GroupName");
124    if (!name.empty()) {
125      GroupInfo &info = groupInfoByName[name];
126      recordGroupMap[R] = &info;
127    }
128  }
129
130  for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
131    Record *R = checkers[i];
132    Record *package = nullptr;
133    if (DefInit *
134          DI = dyn_cast<DefInit>(R->getValueInit("ParentPackage")))
135      package = DI->getDef();
136    if (!isCheckerNamed(R) && !package)
137      PrintFatalError(R->getLoc(), "Checker '" + R->getName() +
138                      "' is neither named, nor in a package!");
139
140    if (isCheckerNamed(R)) {
141      // Create a pseudo-group to hold this checker.
142      std::string fullName = getCheckerFullName(R);
143      GroupInfo &info = groupInfoByName[fullName];
144      info.Hidden = R->getValueAsBit("Hidden");
145      recordGroupMap[R] = &info;
146      info.Checkers.insert(R);
147    } else {
148      recordGroupMap[package]->Checkers.insert(R);
149    }
150
151    Record *currR = isCheckerNamed(R) ? R : package;
152    // Insert the checker and its parent packages into the subgroups set of
153    // the corresponding parent package.
154    while (DefInit *DI
155             = dyn_cast<DefInit>(currR->getValueInit("ParentPackage"))) {
156      Record *parentPackage = DI->getDef();
157      recordGroupMap[parentPackage]->SubGroups.insert(currR);
158      currR = parentPackage;
159    }
160    // Insert the checker into the set of its group.
161    if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group")))
162      recordGroupMap[DI->getDef()]->Checkers.insert(R);
163  }
164
165  // If a package is in group, add all its checkers and its sub-packages
166  // checkers into the group.
167  for (unsigned i = 0, e = packages.size(); i != e; ++i)
168    if (DefInit *DI = dyn_cast<DefInit>(packages[i]->getValueInit("Group")))
169      addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
170
171  typedef std::map<std::string, const Record *> SortedRecords;
172  typedef llvm::DenseMap<const Record *, unsigned> RecToSortIndex;
173
174  SortedRecords sortedGroups;
175  RecToSortIndex groupToSortIndex;
176  OS << "\n#ifdef GET_GROUPS\n";
177  {
178    for (unsigned i = 0, e = checkerGroups.size(); i != e; ++i)
179      sortedGroups[checkerGroups[i]->getValueAsString("GroupName")]
180                   = checkerGroups[i];
181
182    unsigned sortIndex = 0;
183    for (SortedRecords::iterator
184           I = sortedGroups.begin(), E = sortedGroups.end(); I != E; ++I) {
185      const Record *R = I->second;
186
187      OS << "GROUP(" << "\"";
188      OS.write_escaped(R->getValueAsString("GroupName")) << "\"";
189      OS << ")\n";
190
191      groupToSortIndex[R] = sortIndex++;
192    }
193  }
194  OS << "#endif // GET_GROUPS\n\n";
195
196  OS << "\n#ifdef GET_PACKAGES\n";
197  {
198    SortedRecords sortedPackages;
199    for (unsigned i = 0, e = packages.size(); i != e; ++i)
200      sortedPackages[getPackageFullName(packages[i])] = packages[i];
201
202    for (SortedRecords::iterator
203           I = sortedPackages.begin(), E = sortedPackages.end(); I != E; ++I) {
204      const Record &R = *I->second;
205
206      OS << "PACKAGE(" << "\"";
207      OS.write_escaped(getPackageFullName(&R)) << "\", ";
208      // Group index
209      if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group")))
210        OS << groupToSortIndex[DI->getDef()] << ", ";
211      else
212        OS << "-1, ";
213      // Hidden bit
214      if (isHidden(R))
215        OS << "true";
216      else
217        OS << "false";
218      OS << ")\n";
219    }
220  }
221  OS << "#endif // GET_PACKAGES\n\n";
222
223  OS << "\n#ifdef GET_CHECKERS\n";
224  for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
225    const Record &R = *checkers[i];
226
227    OS << "CHECKER(" << "\"";
228    std::string name;
229    if (isCheckerNamed(&R))
230      name = getCheckerFullName(&R);
231    OS.write_escaped(name) << "\", ";
232    OS << R.getName() << ", ";
233    OS << getStringValue(R, "DescFile") << ", ";
234    OS << "\"";
235    OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
236    // Group index
237    if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group")))
238      OS << groupToSortIndex[DI->getDef()] << ", ";
239    else
240      OS << "-1, ";
241    // Hidden bit
242    if (isHidden(R))
243      OS << "true";
244    else
245      OS << "false";
246    OS << ")\n";
247  }
248  OS << "#endif // GET_CHECKERS\n\n";
249
250  unsigned index = 0;
251  for (std::map<std::string, GroupInfo>::iterator
252         I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I)
253    I->second.Index = index++;
254
255  // Walk through the packages/groups/checkers emitting an array for each
256  // set of checkers and an array for each set of subpackages.
257
258  OS << "\n#ifdef GET_MEMBER_ARRAYS\n";
259  unsigned maxLen = 0;
260  for (std::map<std::string, GroupInfo>::iterator
261         I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I) {
262    maxLen = std::max(maxLen, (unsigned)I->first.size());
263
264    llvm::DenseSet<const Record *> &checkers = I->second.Checkers;
265    if (!checkers.empty()) {
266      OS << "static const short CheckerArray" << I->second.Index << "[] = { ";
267      // Make the output order deterministic.
268      std::map<int, const Record *> sorted;
269      for (llvm::DenseSet<const Record *>::iterator
270             I = checkers.begin(), E = checkers.end(); I != E; ++I)
271        sorted[(*I)->getID()] = *I;
272
273      for (std::map<int, const Record *>::iterator
274             I = sorted.begin(), E = sorted.end(); I != E; ++I)
275        OS << checkerRecIndexMap[I->second] << ", ";
276      OS << "-1 };\n";
277    }
278
279    llvm::DenseSet<const Record *> &subGroups = I->second.SubGroups;
280    if (!subGroups.empty()) {
281      OS << "static const short SubPackageArray" << I->second.Index << "[] = { ";
282      // Make the output order deterministic.
283      std::map<int, const Record *> sorted;
284      for (llvm::DenseSet<const Record *>::iterator
285             I = subGroups.begin(), E = subGroups.end(); I != E; ++I)
286        sorted[(*I)->getID()] = *I;
287
288      for (std::map<int, const Record *>::iterator
289             I = sorted.begin(), E = sorted.end(); I != E; ++I) {
290        OS << recordGroupMap[I->second]->Index << ", ";
291      }
292      OS << "-1 };\n";
293    }
294  }
295  OS << "#endif // GET_MEMBER_ARRAYS\n\n";
296
297  OS << "\n#ifdef GET_CHECKNAME_TABLE\n";
298  for (std::map<std::string, GroupInfo>::iterator
299         I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I) {
300    // Group option string.
301    OS << "  { \"";
302    OS.write_escaped(I->first) << "\","
303                               << std::string(maxLen-I->first.size()+1, ' ');
304
305    if (I->second.Checkers.empty())
306      OS << "0, ";
307    else
308      OS << "CheckerArray" << I->second.Index << ", ";
309
310    // Subgroups.
311    if (I->second.SubGroups.empty())
312      OS << "0, ";
313    else
314      OS << "SubPackageArray" << I->second.Index << ", ";
315
316    OS << (I->second.Hidden ? "true" : "false");
317
318    OS << " },\n";
319  }
320  OS << "#endif // GET_CHECKNAME_TABLE\n\n";
321}
322} // end namespace clang
323