[analyzer][NFC] Enable access to CodeGenOptions from analyzer's instances

[ASDenysPetrov]

Summary

Passed a CodeGenOptions reference from CompilerInstance to AnalysisConsumer and then to AnalysisManager and CheckerManager to enable access to the options for CSA instances such as StoreManager, ConstraintManager and others, This patch is a preliminary one for D114718.

NOTE: The half of the changes is just formatting.

[steakhal]

Sweet!
I think commit titles are not punctuated, even though they start with an uppercase letter.

[ASDenysPetrov]

Fixed failed unittest (Syntax error).

[ASDenysPetrov]

In D114006#3135456, @steakhal wrote:

Sweet!
I think commit titles are not punctuated, even though they start with an uppercase letter.

Thanks! That depends on the mood at the particular moment :) But seriously, it's an automatic typo. I do it every other time :) Fixed.

[martong]

LGTM!

[ASDenysPetrov]

In D114006#3142313, @martong wrote:

LGTM!

Thanks, guys!
I'll load it as soon as D110927 also be ready for load(I'm working on it), as this patch is just a preparatory one.

[ASDenysPetrov]

Passed a CodeGenOptions reference to CheckerManager as well. (Adjusted to D114718)

[ASDenysPetrov]

Fixed unit test.

clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

 enum class ObjCMessageVisitKind {
   Pre,
   Post,
   MessageNil
 };
 
 class CheckerManager {
   ASTContext *Context = nullptr;
-  const LangOptions LangOpts;
+  const LangOptions &LangOpts;
+  const CodeGenOptions &CodeGenOpts;
   const AnalyzerOptions &AOptions;
   const Preprocessor *PP = nullptr;
   CheckerNameRef CurrentCheckerName;
   DiagnosticsEngine &Diags;
   std::unique_ptr<CheckerRegistryData> RegistryData;
 
 public:
   // These constructors are defined in the Frontend library, because
   // CheckerRegistry, a crucial component of the initialization is in there.
   // CheckerRegistry cannot be moved to the Core library, because the checker
   // registration functions are defined in the Checkers library, and the library
   // dependencies look like this: Core -> Checkers -> Frontend.
 
   CheckerManager(
-      ASTContext &Context, AnalyzerOptions &AOptions, const Preprocessor &PP,
+      ASTContext &Context, AnalyzerOptions &AOptions,
+      const CodeGenOptions &CGOpts, const Preprocessor &PP,
       ArrayRef<std::string> plugins,
       ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns);
 
   /// Constructs a CheckerManager that ignores all non TblGen-generated
   /// checkers. Useful for unit testing, unless the checker infrastructure
   /// itself is tested.
   CheckerManager(ASTContext &Context, AnalyzerOptions &AOptions,
-                 const Preprocessor &PP)
-      : CheckerManager(Context, AOptions, PP, {}, {}) {}
+                 const CodeGenOptions &CGOpts, const Preprocessor &PP)
+      : CheckerManager(Context, AOptions, CGOpts, PP, {}, {}) {}
 
   /// Constructs a CheckerManager without requiring an AST. No checker
   /// registration will take place. Only useful when one needs to print the
   /// help flags through CheckerRegistryData, and the AST is unavalaible.
   CheckerManager(AnalyzerOptions &AOptions, const LangOptions &LangOpts,
-                 DiagnosticsEngine &Diags, ArrayRef<std::string> plugins);
+                 const CodeGenOptions &CGOpts, DiagnosticsEngine &Diags,
+                 ArrayRef<std::string> plugins);
 
   ~CheckerManager();
 
   void setCurrentCheckerName(CheckerNameRef name) { CurrentCheckerName = name; }
   CheckerNameRef getCurrentCheckerName() const { return CurrentCheckerName; }
 
   bool hasPathSensitiveCheckers() const;
 
   void finishedCheckerRegistration();
 
   const LangOptions &getLangOpts() const { return LangOpts; }
+  const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }
   const AnalyzerOptions &getAnalyzerOptions() const { return AOptions; }
   const Preprocessor &getPreprocessor() const {
     assert(PP);
     return *PP;
   }
   const CheckerRegistryData &getCheckerRegistryData() const {
     return *RegistryData;
   }

clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

 
 class AnalysisManager : public BugReporterData {
   virtual void anchor();
   AnalysisDeclContextManager AnaCtxMgr;
 
   ASTContext &Ctx;
   Preprocessor &PP;
   const LangOptions &LangOpts;
+  const CodeGenOptions &CodeGenOpts;
   PathDiagnosticConsumers PathConsumers;
 
   // Configurable components creators.
   StoreManagerCreator CreateStoreMgr;
   ConstraintManagerCreator CreateConstraintMgr;
 
   CheckerManager *CheckerMgr;
 
 public:
   AnalyzerOptions &options;
 
   AnalysisManager(ASTContext &ctx, Preprocessor &PP,
                   const PathDiagnosticConsumers &Consumers,
                   StoreManagerCreator storemgr,
                   ConstraintManagerCreator constraintmgr,
                   CheckerManager *checkerMgr, AnalyzerOptions &Options,
+                  const CodeGenOptions &CGOpts,
                   CodeInjector *injector = nullptr);
 
   ~AnalysisManager() override;
 
   void ClearContexts() {
     AnaCtxMgr.clear();
   }
 
   AnalysisDeclContextManager& getAnalysisDeclContextManager() {
     return AnaCtxMgr;
   }
 
   Preprocessor &getPreprocessor() override { return PP; }
 
   StoreManagerCreator getStoreManagerCreator() {
     return CreateStoreMgr;
   }
 
   AnalyzerOptions& getAnalyzerOptions() override {
     return options;
   }
 
+  const CodeGenOptions &getCodeGenOptions() const { return CodeGenOpts; }
+
   ConstraintManagerCreator getConstraintManagerCreator() {
     return CreateConstraintMgr;
   }
 
   CheckerManager *getCheckerManager() const { return CheckerMgr; }
 
   ASTContext &getASTContext() override {
     return Ctx;

clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp

 //===-- AnalysisManager.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 
 using namespace clang;
 using namespace ento;
 
 void AnalysisManager::anchor() { }
 
-AnalysisManager::AnalysisManager(ASTContext &ASTCtx, Preprocessor &PP,
-                                 const PathDiagnosticConsumers &PDC,
-                                 StoreManagerCreator storemgr,
-                                 ConstraintManagerCreator constraintmgr,
-                                 CheckerManager *checkerMgr,
-                                 AnalyzerOptions &Options,
-                                 CodeInjector *injector)
+AnalysisManager::AnalysisManager(
+    ASTContext &ASTCtx, Preprocessor &PP, const PathDiagnosticConsumers &PDC,
+    StoreManagerCreator storemgr, ConstraintManagerCreator constraintmgr,
+    CheckerManager *checkerMgr, AnalyzerOptions &Options,
+    const CodeGenOptions &CGOpts, CodeInjector *injector)
     : AnaCtxMgr(
           ASTCtx, Options.UnoptimizedCFG,
           Options.ShouldIncludeImplicitDtorsInCFG,
-          /*addInitializers=*/true,
-          Options.ShouldIncludeTemporaryDtorsInCFG,
+          /*addInitializers=*/true, Options.ShouldIncludeTemporaryDtorsInCFG,
           Options.ShouldIncludeLifetimeInCFG,
           // Adding LoopExit elements to the CFG is a requirement for loop
           // unrolling.
-          Options.ShouldIncludeLoopExitInCFG ||
-            Options.ShouldUnrollLoops,
-          Options.ShouldIncludeScopesInCFG,
-          Options.ShouldSynthesizeBodies,
+          Options.ShouldIncludeLoopExitInCFG || Options.ShouldUnrollLoops,
+          Options.ShouldIncludeScopesInCFG, Options.ShouldSynthesizeBodies,
           Options.ShouldConditionalizeStaticInitializers,
           /*addCXXNewAllocator=*/true,
           Options.ShouldIncludeRichConstructorsInCFG,
           Options.ShouldElideConstructors,
-          /*addVirtualBaseBranches=*/true,
-          injector),
-      Ctx(ASTCtx), PP(PP), LangOpts(ASTCtx.getLangOpts()),
+          /*addVirtualBaseBranches=*/true, injector),
+      Ctx(ASTCtx), PP(PP), LangOpts(ASTCtx.getLangOpts()), CodeGenOpts(CGOpts),
       PathConsumers(PDC), CreateStoreMgr(storemgr),
       CreateConstraintMgr(constraintmgr), CheckerMgr(checkerMgr),
       options(Options) {
   AnaCtxMgr.getCFGBuildOptions().setAllAlwaysAdd();
   AnaCtxMgr.getCFGBuildOptions().OmitImplicitValueInitializers = true;
   AnaCtxMgr.getCFGBuildOptions().AddCXXDefaultInitExprInAggregates =
       Options.ShouldIncludeDefaultInitForAggregates;
 }

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

class AnalysisConsumer : public AnalysisASTConsumer,
 
   std::vector<std::function<void(CheckerRegistry &)>> CheckerRegistrationFns;
 
 public:
   ASTContext *Ctx;
   Preprocessor &PP;
   const std::string OutDir;
   AnalyzerOptionsRef Opts;
+  const CodeGenOptions &CodeGenOpts;
   ArrayRef<std::string> Plugins;
   CodeInjector *Injector;
   cross_tu::CrossTranslationUnitContext CTU;
 
   /// Stores the declarations from the local translation unit.
   /// Note, we pre-compute the local declarations at parse time as an
   /// optimization to make sure we do not deserialize everything from disk.
   /// The local declaration to all declarations ratio might be very small when
public:
   std::unique_ptr<llvm::Timer> ExprEngineTimer;
   std::unique_ptr<llvm::Timer> BugReporterTimer;
 
   /// The information about analyzed functions shared throughout the
   /// translation unit.
   FunctionSummariesTy FunctionSummaries;
 
   AnalysisConsumer(CompilerInstance &CI, const std::string &outdir,
-                   AnalyzerOptionsRef opts, ArrayRef<std::string> plugins,
-                   CodeInjector *injector)
+                   AnalyzerOptionsRef opts, const CodeGenOptions &CGOpts,
+                   ArrayRef<std::string> plugins, CodeInjector *injector)
       : RecVisitorMode(0), RecVisitorBR(nullptr), Ctx(nullptr),
         PP(CI.getPreprocessor()), OutDir(outdir), Opts(std::move(opts)),
-        Plugins(plugins), Injector(injector), CTU(CI),
+        CodeGenOpts(CGOpts), Plugins(plugins), Injector(injector), CTU(CI),
         MacroExpansions(CI.getLangOpts()) {
     DigestAnalyzerOptions();
     if (Opts->AnalyzerDisplayProgress || Opts->PrintStats ||
         Opts->ShouldSerializeStats) {
       AnalyzerTimers = std::make_unique<llvm::TimerGroup>(
           "analyzer", "Analyzer timers");
       SyntaxCheckTimer = std::make_unique<llvm::Timer>(
           "syntaxchecks", "Syntax-based analysis time", *AnalyzerTimers);
if (Loc.isValid()) {
 
       llvm::errs() << ": " << Loc.getFilename() << ' '
                    << AnalysisDeclContext::getFunctionName(D);
     }
   }
 
   void Initialize(ASTContext &Context) override {
     Ctx = &Context;
-    checkerMgr = std::make_unique<CheckerManager>(*Ctx, *Opts, PP, Plugins,
-                                                  CheckerRegistrationFns);
+    checkerMgr = std::make_unique<CheckerManager>(
+        *Ctx, *Opts, CodeGenOpts, PP, Plugins, CheckerRegistrationFns);
 
-    Mgr = std::make_unique<AnalysisManager>(*Ctx, PP, PathConsumers,
-                                            CreateStoreMgr, CreateConstraintMgr,
-                                            checkerMgr.get(), *Opts, Injector);
+    Mgr = std::make_unique<AnalysisManager>(
+        *Ctx, PP, PathConsumers, CreateStoreMgr, CreateConstraintMgr,
+        checkerMgr.get(), *Opts, CodeGenOpts, Injector);
   }
 
   /// Store the top level decls in the set to be processed later on.
   /// (Doing this pre-processing avoids deserialization of data from PCH.)
   bool HandleTopLevelDecl(DeclGroupRef D) override;
   void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override;
 
   void HandleTranslationUnit(ASTContext &C) override;

 ento::CreateAnalysisConsumer(CompilerInstance &CI) {
   // Disable the effects of '-Werror' when using the AnalysisConsumer.
   CI.getPreprocessor().getDiagnostics().setWarningsAsErrors(false);
 
   AnalyzerOptionsRef analyzerOpts = CI.getAnalyzerOpts();
   bool hasModelPath = analyzerOpts->Config.count("model-path") > 0;
 
   return std::make_unique<AnalysisConsumer>(
-      CI, CI.getFrontendOpts().OutputFile, analyzerOpts,
+      CI, CI.getFrontendOpts().OutputFile, analyzerOpts, CI.getCodeGenOpts(),
       CI.getFrontendOpts().Plugins,
       hasModelPath ? new ModelInjector(CI) : nullptr);
 }

clang/lib/StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp

 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 using namespace clang;
 using namespace ento;
 
+static CheckerManager CreateCheckerManager(CompilerInstance &CI) {
+  return {*CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getCodeGenOpts(),
+          CI.getDiagnostics(), CI.getFrontendOpts().Plugins};
+}
+
 void ento::printCheckerHelp(raw_ostream &out, CompilerInstance &CI) {
   out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
   out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
 
-  auto CheckerMgr = std::make_unique<CheckerManager>(
-      *CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getDiagnostics(),
-      CI.getFrontendOpts().Plugins);
-
-  CheckerMgr->getCheckerRegistryData().printCheckerWithDescList(
+  CreateCheckerManager(CI).getCheckerRegistryData().printCheckerWithDescList(
       *CI.getAnalyzerOpts(), out);
 }
 
 void ento::printEnabledCheckerList(raw_ostream &out, CompilerInstance &CI) {
   out << "OVERVIEW: Clang Static Analyzer Enabled Checkers List\n\n";
 
-  auto CheckerMgr = std::make_unique<CheckerManager>(
-      *CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getDiagnostics(),
-      CI.getFrontendOpts().Plugins);
-
-  CheckerMgr->getCheckerRegistryData().printEnabledCheckerList(out);
+  CreateCheckerManager(CI).getCheckerRegistryData().printEnabledCheckerList(
+      out);
 }
 
 void ento::printCheckerConfigList(raw_ostream &out, CompilerInstance &CI) {
 
-  auto CheckerMgr = std::make_unique<CheckerManager>(
-      *CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getDiagnostics(),
-      CI.getFrontendOpts().Plugins);
-
-  CheckerMgr->getCheckerRegistryData().printCheckerOptionList(
+  CreateCheckerManager(CI).getCheckerRegistryData().printCheckerOptionList(
       *CI.getAnalyzerOpts(), out);
 }
 
 void ento::printAnalyzerConfigList(raw_ostream &out) {
   // FIXME: This message sounds scary, should be scary, but incorrectly states
   // that all configs are super dangerous. In reality, many of them should be
   // accessible to the user. We should create a user-facing subset of config
   // options under a different frontend flag.

clang/lib/StaticAnalyzer/Frontend/CreateCheckerManager.cpp

 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
 #include <memory>
 
 namespace clang {
 namespace ento {
 
 CheckerManager::CheckerManager(
-    ASTContext &Context, AnalyzerOptions &AOptions, const Preprocessor &PP,
+    ASTContext &Context, AnalyzerOptions &AOptions,
+    const CodeGenOptions &CGOpts, const Preprocessor &PP,
     ArrayRef<std::string> plugins,
     ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns)
-    : Context(&Context), LangOpts(Context.getLangOpts()), AOptions(AOptions),
-      PP(&PP), Diags(Context.getDiagnostics()),
+    : Context(&Context), LangOpts(Context.getLangOpts()), CodeGenOpts(CGOpts),
+      AOptions(AOptions), PP(&PP), Diags(Context.getDiagnostics()),
       RegistryData(std::make_unique<CheckerRegistryData>()) {
   CheckerRegistry Registry(*RegistryData, plugins, Context.getDiagnostics(),
                            AOptions, checkerRegistrationFns);
   Registry.initializeRegistry(*this);
   Registry.initializeManager(*this);
   finishedCheckerRegistration();
 }
 
 CheckerManager::CheckerManager(AnalyzerOptions &AOptions,
                                const LangOptions &LangOpts,
+                               const CodeGenOptions &CGOpts,
                                DiagnosticsEngine &Diags,
                                ArrayRef<std::string> plugins)
-    : LangOpts(LangOpts), AOptions(AOptions), Diags(Diags),
+    : LangOpts(LangOpts), CodeGenOpts(CGOpts), AOptions(AOptions), Diags(Diags),
       RegistryData(std::make_unique<CheckerRegistryData>()) {
   CheckerRegistry Registry(*RegistryData, plugins, Diags, AOptions, {});
   Registry.initializeRegistry(*this);
 }
 
 CheckerManager::~CheckerManager() {
   for (const auto &CheckerDtor : CheckerDtors)
     CheckerDtor();
 }
 
 } // namespace ento
 } // namespace clang

clang/unittests/StaticAnalyzer/Reusables.h

 
 public:
   ExprEngineConsumer(CompilerInstance &C)
       : C(C),
         ChkMgr(C.getASTContext(), *C.getAnalyzerOpts(), C.getPreprocessor()),
         CTU(C), Consumers(),
         AMgr(C.getASTContext(), C.getPreprocessor(), Consumers,
              CreateRegionStoreManager, CreateRangeConstraintManager, &ChkMgr,
-             *C.getAnalyzerOpts()),
+             *C.getAnalyzerOpts(), C.getCodeGenOpts()),
         VisitedCallees(), FS(),
         Eng(CTU, AMgr, &VisitedCallees, &FS, ExprEngine::Inline_Regular) {}
 };
 
 struct ExpectedLocationTy {
   unsigned Line;
   unsigned Column;