1//===--- CheckerRegistration.cpp - Registration for the Analyzer Checkers -===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Defines the registration function for the analyzer checkers.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
14#include "clang/Basic/Diagnostic.h"
15#include "clang/Frontend/FrontendDiagnostic.h"
16#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
17#include "clang/StaticAnalyzer/Core/CheckerManager.h"
18#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
19#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/Support/raw_ostream.h"
22#include <memory>
23
24using namespace clang;
25using namespace ento;
26
27std::unique_ptr<CheckerManager> ento::createCheckerManager(
28    ASTContext &context,
29    AnalyzerOptions &opts,
30    ArrayRef<std::string> plugins,
31    ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
32    DiagnosticsEngine &diags) {
33  auto checkerMgr = std::make_unique<CheckerManager>(context, opts);
34
35  CheckerRegistry allCheckers(plugins, diags, opts, context.getLangOpts(),
36                              checkerRegistrationFns);
37
38  allCheckers.initializeManager(*checkerMgr);
39  allCheckers.validateCheckerOptions();
40  checkerMgr->finishedCheckerRegistration();
41
42  return checkerMgr;
43}
44
45void ento::printCheckerHelp(raw_ostream &out, ArrayRef<std::string> plugins,
46                            AnalyzerOptions &anopts,
47                            DiagnosticsEngine &diags,
48                            const LangOptions &langOpts) {
49  out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
50  out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
51
52  CheckerRegistry(plugins, diags, anopts, langOpts)
53      .printCheckerWithDescList(out);
54}
55
56void ento::printEnabledCheckerList(raw_ostream &out,
57                                   ArrayRef<std::string> plugins,
58                                   AnalyzerOptions &anopts,
59                                   DiagnosticsEngine &diags,
60                                   const LangOptions &langOpts) {
61  out << "OVERVIEW: Clang Static Analyzer Enabled Checkers List\n\n";
62
63  CheckerRegistry(plugins, diags, anopts, langOpts)
64      .printEnabledCheckerList(out);
65}
66
67void ento::printCheckerConfigList(raw_ostream &OS,
68                                  ArrayRef<std::string> plugins,
69                                  AnalyzerOptions &opts,
70                                  DiagnosticsEngine &diags,
71                                  const LangOptions &LangOpts) {
72  CheckerRegistry(plugins, diags, opts, LangOpts)
73      .printCheckerOptionList(OS);
74}
75
76void ento::printAnalyzerConfigList(raw_ostream &out) {
77  // FIXME: This message sounds scary, should be scary, but incorrectly states
78  // that all configs are super dangerous. In reality, many of them should be
79  // accessible to the user. We should create a user-facing subset of config
80  // options under a different frontend flag.
81  out << R"(
82OVERVIEW: Clang Static Analyzer -analyzer-config Option List
83
84The following list of configurations are meant for development purposes only, as
85some of the variables they define are set to result in the most optimal
86analysis. Setting them to other values may drastically change how the analyzer
87behaves, and may even result in instabilities, crashes!
88
89USAGE: -analyzer-config <OPTION1=VALUE,OPTION2=VALUE,...>
90       -analyzer-config OPTION1=VALUE, -analyzer-config OPTION2=VALUE, ...
91OPTIONS:
92)";
93
94  using OptionAndDescriptionTy = std::pair<StringRef, std::string>;
95  OptionAndDescriptionTy PrintableOptions[] = {
96#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
97    {                                                                          \
98      CMDFLAG,                                                                 \
99      llvm::Twine(llvm::Twine() + "(" +                                        \
100                  (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) +      \
101                  ") " DESC                                                    \
102                  " (default: " #DEFAULT_VAL ")").str()                        \
103    },
104
105#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
106                                             SHALLOW_VAL, DEEP_VAL)            \
107    {                                                                          \
108      CMDFLAG,                                                                 \
109      llvm::Twine(llvm::Twine() + "(" +                                        \
110                  (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) +      \
111                  ") " DESC                                                    \
112                  " (default: " #SHALLOW_VAL " in shallow mode, " #DEEP_VAL    \
113                  " in deep mode)").str()                                      \
114    },
115#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
116#undef ANALYZER_OPTION
117#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
118  };
119
120  llvm::sort(PrintableOptions, [](const OptionAndDescriptionTy &LHS,
121                                  const OptionAndDescriptionTy &RHS) {
122    return LHS.first < RHS.first;
123  });
124
125  for (const auto &Pair : PrintableOptions) {
126    AnalyzerOptions::printFormattedEntry(out, Pair, /*InitialPad*/ 2,
127                                         /*EntryWidth*/ 30,
128                                         /*MinLineWidth*/ 70);
129    out << "\n\n";
130  }
131}
132