[analyzer] Evaluate all non-checker config options before analysis

[Szelethus]

Summary

This patch contains very little logic but touches a lot of lines.

Now that we're confident that all non-checker configs are gathered, I went ahead and did some actual changes to how AnalyzerOptions works.

This patch is a proposal to evaluate all config options (and possibly emit warning about them) at the beginning of the analysis, rather then whenever a getter function is called for it. This is done by changing the generated Optional<TYPE> fields' accessibility to public, evaluating all options as soon as the ConfigTable is assembled, and removing generated getters, as are they are no longer necessary. Now, every single public function (except parseConfigs) is const, as should AnalyzerOptions be after options are parsed (coming soon™ in a followup patch).

The removal of those getters implied however that every single use of those getters had to be changed (Opts.shouldDoThat() -> Opts.ShouldDoThat.getValue()), and I got to simplify the def file. I clang-formatted it, and since I don't expect the format to change for a good long while, I think it should be clang-formatted in the future whenever.

The actual the actual implementation of warnings is coming soon™.

[Szelethus]

The reason why I removed the getter functions and went ahead with the gigantic refactor is that getter functions actually changed the state of AnalyzerOptions, as they were responsible with the initialization of each option. Now, in the .def file, not all options had getter functions, so I couldn't just get away with calling every getter function once. Besides, a separate identifier for a field name (NAME) and getter function name (CREATE_FN) didn't make much sense anyways.

Granted, NAME and CREATE_FN were redundant when I added them myself, but the idea there was to regenerate the exact same state AnalyzerOptions was in at the time.

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

234

This check should and will be moved to parseConfigs in a followup patch.

[Szelethus]

What are the feelings on moving some functions to the header file? That's the one thing I'm unsure about regarding this patch. I could've moved them to CompilerInvocation.cpp, but I since I plan on making ConfigTable private, CompilerInvocation needs to be a friend of AnalyzerOptions. Not that it's the end of the world, and similar classes (e.g.: LangOptions) work similarly.

The reason why I didn't do it straight away is that

• it's nice that AnalyzerOptions handles configs on it's own.
• if someone would like add a new config option and also add constraints (like it has to be an existing file) to that, facing the longer compilation times will be a burden anyways (because the .def file has to be modified), so I thought the maintenance cost of parseConfig won't be THAT bad,

but I'd concede to the fact that these aren't the greatest of concerns, though.

[Szelethus]

Polite ping. :)

[NoQ]

I guess i'm running out of steam for today :)

Opts.shouldDoThat() -> Opts.ShouldDoThat.getValue()

Is this really unavoidable? Like, what makes them optional when they're always non-optional? Maybe just somehow prevent un-eagerly-initialized AnalyzerConfig from appearing anywhere in the program?

[Szelethus]

In D53692#1285091, @NoQ wrote:

I guess i'm running out of steam for today :)

Opts.shouldDoThat() -> Opts.ShouldDoThat.getValue()

Is this really unavoidable? Like, what makes them optional when they're always non-optional? Maybe just somehow prevent un-eagerly-initialized AnalyzerConfig from appearing anywhere in the program?

Thats a fair point, the reason why I kept Optional<T> is the extra safety -- it took a good couple hours to make this patch, and it didn't took days thanks to the hasValue() assert, since, well, how macros get expanded is always a surprise. But sure, ideally it shouldn't be there.

[Szelethus]

Also, thank you so much for the feedback on this, and almost every single other patch I made!

[xazax.hun]

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

234

Just make sure to commit the patches together to not regress this check.

[NoQ]

test/Analysis/analyzer-config.c

3–4

The code is no longer necessary, right? All options are now initialized eagerly and there's no need to analyze any code to get them initialized.

test/Analysis/analyzer-config.cpp

1

Aaand this test should probably be removed entirely.

[Szelethus]

• Moved initializer functions to CompilerInvocation.cpp, like every other Options-like class.
• The fields for options are no longer Optional
• Fixed the test files

[Szelethus]

test/Analysis/analyzer-config.c

3–4

Correct :)

[NoQ]

Thanks, this is really wonderful.

test/Analysis/analyzer-config.cpp

1

I think this one's not actually done^^

[Szelethus]

Thanks! This patch was the last for a while directly related to non-checker config options, I'm currently stuck on them as I unearthed countless bugs that I have to fix beforehand. (Did you know that clang unit tests do not run with check-clang-analysis?)

test/Analysis/analyzer-config.cpp

1

Uh, right, I misunderstood what you meant :D

[NoQ]

In D53692#1293778, @Szelethus wrote:

Did you know that clang unit tests do not run with check-clang-analysis?

Well, *some* unit tests definitely do run under check-clang-analysis.

[NoQ]

In D53692#1293781, @NoQ wrote:

In D53692#1293778, @Szelethus wrote:

Did you know that clang unit tests do not run with check-clang-analysis?

Well, *some* unit tests definitely do run under check-clang-analysis.

I think they're actually compiled but indeed not run. Ugh. I guess it should be fixed.

[Szelethus]

In D53692#1313956, @NoQ wrote:

In D53692#1293781, @NoQ wrote:

In D53692#1293778, @Szelethus wrote:

Did you know that clang unit tests do not run with check-clang-analysis?

Well, *some* unit tests definitely do run under check-clang-analysis.

I think they're actually compiled but indeed not run. Ugh. I guess it should be fixed.

Uhh, yea, forgot to send my comment with the same observation. I tried to fix it myself, but a day and a half of CMake made me appreciate even preprocessor macros more then ever.

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

 #ifndef LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
 #define LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace clang {
 
 namespace ento {
 
public:
 
   static std::vector<StringRef>
   getRegisteredCheckers(bool IncludeExperimental = false);
 
   /// Pair of checker name and enable/disable.
   std::vector<std::pair<std::string, bool>> CheckersControlList;
 
   /// A key-value table of use-specified configuration values.
+  // TODO: This shouldn't be public.
   ConfigTable Config;
   AnalysisStores AnalysisStoreOpt = RegionStoreModel;
   AnalysisConstraints AnalysisConstraintsOpt = RangeConstraintsModel;
   AnalysisDiagClients AnalysisDiagOpt = PD_HTML;
   AnalysisPurgeMode AnalysisPurgeOpt = PurgeStmt;
 
   std::string AnalyzeSpecificFunction;
 
public:
 
   /// The inlining stack depth limit.
   // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).
   unsigned InlineMaxStackDepth = 5;
 
   /// The mode of function selection used during inlining.
   AnalysisInliningMode InliningMode = NoRedundancy;
 
-private:
-
-#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
-  Optional<TYPE> NAME;
 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
                                              SHALLOW_VAL, DEEP_VAL)            \
-  Optional<TYPE> NAME;
+  ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL)
+
+#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
+  TYPE NAME;
+
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
 #undef ANALYZER_OPTION
 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 
-  /// Query an option's string value.
-  ///
-  /// If an option value is not provided, returns the given \p DefaultVal.
-  /// @param [in] Name Name for option to retrieve.
-  /// @param [in] DefaultVal Default value returned if no such option was
-  /// specified.
-  StringRef getStringOption(StringRef OptionName, StringRef DefaultVal);
-
-  void initOption(Optional<StringRef> &V, StringRef Name,
-                                          StringRef DefaultVal);
-
-  void initOption(Optional<bool> &V, StringRef Name, bool DefaultVal);
-
-  void initOption(Optional<unsigned> &V, StringRef Name,
-                                         unsigned DefaultVal);
-public:
   AnalyzerOptions()
       : DisableAllChecks(false), ShowCheckerHelp(false),
         ShowEnabledCheckerList(false), AnalyzeAll(false),
         AnalyzerDisplayProgress(false), AnalyzeNestedBlocks(false),
         eagerlyAssumeBinOpBifurcation(false), TrimGraph(false),
         visualizeExplodedGraphWithGraphViz(false),
         UnoptimizedCFG(false),
         PrintStats(false), NoRetryExhausted(false) {}
#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer
   /// ones.
   StringRef getCheckerStringOption(StringRef Name, StringRef DefaultVal,
                               const ento::CheckerBase *C,
                               bool SearchInParents = false) const;
 
-#define ANALYZER_OPTION_GEN_FN(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL,  \
-                               CREATE_FN)                               \
-  TYPE CREATE_FN() {                                                    \
-    initOption(NAME, CMDFLAG, DEFAULT_VAL);                             \
-    return NAME.getValue();                                             \
-  }
-
-#define ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE(                    \
-    TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL, DEEP_VAL, CREATE_FN)        \
-  TYPE CREATE_FN() {                                                    \
-    switch (getUserMode()) {                                            \
-    case UMK_Shallow:                                                   \
-      initOption(NAME, CMDFLAG, SHALLOW_VAL);                           \
-      break;                                                            \
-    case UMK_Deep:                                                      \
-      initOption(NAME, CMDFLAG, DEEP_VAL);                              \
-      break;                                                            \
-    }                                                                   \
-                                                                        \
-    return NAME.getValue();                                             \
-  }
-
-#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
-
-#undef ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE
-#undef ANALYZER_OPTION_WITH_FN
-
   /// Retrieves and sets the UserMode. This is a high-level option,
   /// which is used to set other low-level options. It is not accessible
   /// outside of AnalyzerOptions.
-  UserModeKind getUserMode();
+  UserModeKind getUserMode() const;
 
-  ExplorationStrategyKind getExplorationStrategy();
+  ExplorationStrategyKind getExplorationStrategy() const;
 
   /// Returns the inter-procedural analysis mode.
-  IPAKind getIPAMode();
+  IPAKind getIPAMode() const;
 
   /// Returns the option controlling which C++ member functions will be
   /// considered for inlining.
   ///
   /// This is controlled by the 'c++-inlining' config option.
   ///
   /// \sa CXXMemberInliningMode
-  bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K);
-
-  StringRef getCTUDir();
+  bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const;
 };
 
 using AnalyzerOptionsRef = IntrusiveRefCntPtr<AnalyzerOptions>;
 
+//===----------------------------------------------------------------------===//
+// We'll use AnalyzerOptions in the frontend, but we can't link the frontend
+// with clangStaticAnalyzerCore, because clangStaticAnalyzerCore depends on
+// clangFrontend.
+//
+// For this reason, implement some methods in this header file.
+//===----------------------------------------------------------------------===//
+
+inline UserModeKind AnalyzerOptions::getUserMode() const {
+  auto K = llvm::StringSwitch<llvm::Optional<UserModeKind>>(UserMode)
+    .Case("shallow", UMK_Shallow)
+    .Case("deep", UMK_Deep)
+    .Default(None);
+  assert(K.hasValue() && "User mode is invalid.");
+  return K.getValue();
+}
+
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H

include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

 //===-- AnalyzerOptions.def - Metadata about Static Analyses ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the analyzer options avaible with -analyzer-config.
 //
-//  This file is in part intended for method generation. If it's not included
-//  for that purpose, the following function-like macros should be predefined,
-//  through which all registered options are accessible:
-//
-//    * ANALYZER_OPTION: Register a new option.
-//    * ANALYZER_OPTION_DEPENDS_ON_USER_MODE: Register a new option, default
-//      value depends on the "user-mode" option.
-//
-//  Options where a simple getter method is sufficient are registered with the
-//  following macros:
-//
-//    * ANALYZER_OPTION_GEN_FN: Register a new option, and generate a getter
-//      method for it in AnalyzerOptions.
-//
-//    * ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE: Same as above, but
-//      generates a getter function that depends on the "user-mode" option.
-//
-//  You can only include this file when both or none of the above two macros
-//  are defined!
-//  When they are defined, entries that do not generate functions  won't appear,
-//  and when they aren't, all entries are converted to ANALYZER_OPTION or to
-//  ANALYZER_OPTION_DEPENDS_ON_USER_MODE.
-//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STRINGREF_H
 #error This .def file is expected to be included in translation units where \
 "llvm/ADT/StringRef.h" is already included!
 #endif
 
 #ifdef ANALYZER_OPTION
 #ifndef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 #error If you didn't include this file with the intent of generating methods, \
 define both 'ANALYZER_OPTION' and 'ANALYZER_OPTION_DEPENDS_ON_USER_MODE' macros!
 #endif
 #endif
 
 #ifndef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 #ifdef ANALYZER_OPTION
 #error If you didn't include this file with the intent of generating methods, \
 define both 'ANALYZER_OPTION' and 'ANALYZER_OPTION_DEPENDS_ON_USER_MODE' macros!
 #endif
 #endif
 
-#ifdef ANALYZER_OPTION_GEN_FN
-#ifndef ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE
-#error If you include this file with the intent of generating functions, \
-define both 'ANALYZER_OPTION_GEN_FN' and \
-'ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE' macros!
-#endif
-#endif
-
-#ifdef ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE
-#ifndef ANALYZER_OPTION_GEN_FN
-#error If you include this file with the intent of generating functions, \
-define both 'ANALYZER_OPTION_GEN_FN' and \
-'ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE' macros!
-#endif
-#endif
-
 #ifndef ANALYZER_OPTION
 /// Create a new analyzer option, but dont generate a method for it in
 /// AnalyzerOptions.
 ///
 ///   TYPE - The type of the option object that will be stored in
 ///          AnalyzerOptions. This file is expected to be icluded in translation
 ///          units where AnalyzerOptions.h is included, so types from that
 ///          header should be used.

 ///   SHALLOW_VAL - The default value for CMDFLAG, when "user-mode" was set to
 ///                 "shallow".
 ///   DEEP_VAL - The default value for CMDFLAG, when "user-mode" was set to
 ///              "deep".
 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
                                              SHALLOW_VAL, DEEP_VAL)
 #endif
 
-#ifndef ANALYZER_OPTION_GEN_FN
-/// Create a new analyzer option, and generate a getter method for it in
-/// AnalyzerOptions.
-///
-///   TYPE - The type of the option object that will be stored in
-///          AnalyzerOptions. This file is expected to be icluded in translation
-///          units where AnalyzerOptions.h is included, so types from that
-///          header should be used.
-///   NAME - The name of the option object.
-///   CMDFLAG - The command line flag for the option.
-///             (-analyzer-config CMDFLAG=VALUE)
-///   DESC - Description of the flag.
-///   DEFAULT_VAL - The default value for CMDFLAG.
-///   CREATE_FN - Name of the getter function.
-//
-// If this def file wasn't included with the intent of generating functions,
-// regard all entries as ANALYZER_OPTION.
-#define ANALYZER_OPTION_GEN_FN(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL,         \
-                               CREATE_FN)                                      \
-  ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)
-#endif
+//===----------------------------------------------------------------------===//
+// The "mode" option. Since some options depend on this, we list it on top of
+// this file in order to make sure that the generated field for it is
+// initialized before the rest.
+//===----------------------------------------------------------------------===//
 
-#ifndef ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE
-/// Create a new analyzer option, and generate a getter method for it in
-/// AnalyzerOptions, and make it's default value depend on the "user-mode"
-/// option.
-///
-///   TYPE - The type of the option object that will be stored in
-///          AnalyzerOptions. This file is expected to be icluded in translation
-///          units where AnalyzerOptions.h is included, so types from that
-///          header should be used.
-///   NAME - The name of the option object.
-///   CMDFLAG - The command line flag for the option.
-///               (-analyzer-config CMDFLAG=VALUE)
-///   DESC - Description of the flago.
-///   SHALLOW_VAL - The default value for CMDFLAG, when "user-mode" was set to
-///                 "shallow".
-///   DEEP_VAL - The default value for CMDFLAG, when "user-mode" was set to
-///              "deep".
-///   CREATE_FN - Name of the getter function.
-//
-// If this def file wasn't included with the intent of generating functions,
-// regard all entries as ANALYZER_OPTION_DEPENDS_ON_USER_MODE.
-#define ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE(                           \
-    TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL, DEEP_VAL, CREATE_FN)               \
-  ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL, \
-                                       DEEP_VAL)
-#endif
+ANALYZER_OPTION(
+    StringRef, UserMode, "mode",
+    "(string) Controls the high-level analyzer mode, which influences the "
+    "default settings for some of the lower-level config options (such as "
+    "IPAMode). Value: \"deep\", \"shallow\".",
+    "deep")
 
 //===----------------------------------------------------------------------===//
 // Boolean analyzer options.
 //===----------------------------------------------------------------------===//
 
-ANALYZER_OPTION_GEN_FN(bool, IncludeImplicitDtorsInCFG, "cfg-implicit-dtors",
-                       "Whether or not implicit destructors for C++ objects "
-                       "should be included in the CFG.",
-                       true, includeImplicitDtorsInCFG)
+ANALYZER_OPTION(bool, ShouldIncludeImplicitDtorsInCFG, "cfg-implicit-dtors",
+                true)
 
-ANALYZER_OPTION_GEN_FN(bool, IncludeTemporaryDtorsInCFG, "cfg-temporary-dtors",
-                       "Whether or not the destructors for C++ temporary "
-                       "objects should be included in the CFG.",
-                       true, includeTemporaryDtorsInCFG)
+ANALYZER_OPTION(bool, ShouldIncludeTemporaryDtorsInCFG, "cfg-temporary-dtors",
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, IncludeLifetimeInCFG, "cfg-lifetime",
+ANALYZER_OPTION(
+    bool, ShouldIncludeLifetimeInCFG, "cfg-lifetime",
     "Whether or not end-of-lifetime information should be included in the CFG.",
-    false, includeLifetimeInCFG)
+    false)
 
-ANALYZER_OPTION_GEN_FN(bool, IncludeLoopExitInCFG, "cfg-loopexit",
-                       "Whether or not the end of the loop information should "
-                       "be included in the CFG.",
-                       false, includeLoopExitInCFG)
+ANALYZER_OPTION(bool, ShouldIncludeLoopExitInCFG, "cfg-loopexit",
+                false)
 
-ANALYZER_OPTION_GEN_FN(bool, IncludeRichConstructorsInCFG,
-                       "cfg-rich-constructors",
-                       "Whether or not construction site information should be "
-                       "included in the CFG C++ constructor elements.",
-                       true, includeRichConstructorsInCFG)
+ANALYZER_OPTION(bool, ShouldIncludeRichConstructorsInCFG,
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, IncludeScopesInCFG, "cfg-scopes",
-    "Whether or not scope information should be included in the CFG.", false,
-    includeScopesInCFG)
-
-ANALYZER_OPTION_GEN_FN(
-    bool, InlineTemplateFunctions, "c++-template-inlining",
-    "Whether or not templated functions may be considered for inlining.", true,
-    mayInlineTemplateFunctions)
+ANALYZER_OPTION(
+    bool, ShouldIncludeScopesInCFG, "cfg-scopes",
+    "Whether or not scope information should be included in the CFG.", false)
+
+ANALYZER_OPTION(
+    bool, MayInlineTemplateFunctions, "c++-template-inlining",
+    "Whether or not templated functions may be considered for inlining.", true)
 
-ANALYZER_OPTION_GEN_FN(bool, InlineCXXStandardLibrary, "c++-stdlib-inlining",
-                       "Whether or not C++ standard library functions may be "
-                       "considered for inlining.",
-                       true, mayInlineCXXStandardLibrary)
+ANALYZER_OPTION(bool, MayInlineCXXStandardLibrary, "c++-stdlib-inlining",
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, InlineCXXAllocator, "c++-allocator-inlining",
-    "Whether or not allocator call may be considered for inlining.", true,
-    mayInlineCXXAllocator)
+ANALYZER_OPTION(bool, MayInlineCXXAllocator, "c++-allocator-inlining",
+                "Whether or not allocator call may be considered for inlining.",
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, InlineCXXSharedPtrDtor, "c++-shared_ptr-inlining",
+ANALYZER_OPTION(
+    bool, MayInlineCXXSharedPtrDtor, "c++-shared_ptr-inlining",
     "Whether or not the destructor of C++ 'shared_ptr' may be considered for "
     "inlining. This covers std::shared_ptr, std::tr1::shared_ptr, and "
     "boost::shared_ptr, and indeed any destructor named '~shared_ptr'.",
-    false, mayInlineCXXSharedPtrDtor)
+    false)
 
-ANALYZER_OPTION_GEN_FN(bool, InlineCXXTemporaryDtors, "c++-temp-dtor-inlining",
-                       "Whether C++ temporary destructors should be inlined "
-                       "during analysis. If temporary destructors are disabled "
-                       "in the CFG via the 'cfg-temporary-dtors' option, "
-                       "temporary destructors would not be inlined anyway.",
-                       true, mayInlineCXXTemporaryDtors)
+ANALYZER_OPTION(bool, MayInlineCXXTemporaryDtors, "c++-temp-dtor-inlining",
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, SuppressNullReturnPaths, "suppress-null-return-paths",
+ANALYZER_OPTION(
+    bool, ShouldSuppressNullReturnPaths, "suppress-null-return-paths",
     "Whether or not paths that go through null returns should be suppressed. "
     "This is a heuristic for avoiding bug reports with paths that go through "
     "inlined functions that are more defensive than their callers.",
-    true, shouldSuppressNullReturnPaths)
+    true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, AvoidSuppressingNullArgumentPaths,
+ANALYZER_OPTION(
+    bool, ShouldAvoidSuppressingNullArgumentPaths,
     "avoid-suppressing-null-argument-paths",
     "Whether a bug report should not be suppressed if its path includes a call "
     "with a null argument, even if that call has a null return. This option "
-    "has no effect when #shouldSuppressNullReturnPaths() is false. This is a "
+    "has no effect when ShouldSuppressNullReturnPaths is false. This is a "
     "counter-heuristic to avoid false negatives.",
-    false, shouldAvoidSuppressingNullArgumentPaths)
+    false)
 
-ANALYZER_OPTION_GEN_FN(bool, SuppressInlinedDefensiveChecks,
-                       "suppress-inlined-defensive-checks",
-                       "Whether or not diagnostics containing inlined "
-                       "defensive NULL checks should be suppressed.",
-                       true, shouldSuppressInlinedDefensiveChecks)
+ANALYZER_OPTION(bool, ShouldSuppressInlinedDefensiveChecks,
+                true)
 
-ANALYZER_OPTION_GEN_FN(bool, InlineCXXContainerMethods,
-                       "c++-container-inlining",
-                       "Whether or not methods of C++ container objects may be "
-                       "considered for inlining.",
-                       false, mayInlineCXXContainerMethods)
+ANALYZER_OPTION(bool, MayInlineCXXContainerMethods, "c++-container-inlining",
+                false)
 
-ANALYZER_OPTION_GEN_FN(bool, SuppressFromCXXStandardLibrary,
-                       "suppress-c++-stdlib",
-                       "Whether or not diagnostics reported within the C++ "
-                       "standard library should be suppressed.",
-                       true, shouldSuppressFromCXXStandardLibrary)
+ANALYZER_OPTION(bool, ShouldSuppressFromCXXStandardLibrary,
+                true)
 
-ANALYZER_OPTION_GEN_FN(bool, CrosscheckWithZ3, "crosscheck-with-z3",
-                       "Whether bug reports should be crosschecked with the Z3 "
-                       "constraint manager backend.",
-                       false, shouldCrosscheckWithZ3)
+ANALYZER_OPTION(bool, ShouldCrosscheckWithZ3, "crosscheck-with-z3",
+                false)
 
-ANALYZER_OPTION_GEN_FN(bool, ReportIssuesInMainSourceFile,
-                       "report-in-main-source-file",
-                       "Whether or not the diagnostic report should be always "
-                       "reported in the main source file and not the headers.",
-                       false, shouldReportIssuesInMainSourceFile)
+ANALYZER_OPTION(bool, ShouldReportIssuesInMainSourceFile,
+                false)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, WriteStableReportFilename, "stable-report-filename",
-    "Whether or not the report filename should be random or not.", false,
-    shouldWriteStableReportFilename)
+ANALYZER_OPTION(bool, ShouldWriteStableReportFilename, "stable-report-filename",
+                "Whether or not the report filename should be random or not.",
+                false)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, SerializeStats, "serialize-stats",
+ANALYZER_OPTION(
+    bool, ShouldSerializeStats, "serialize-stats",
     "Whether the analyzer should serialize statistics to plist output. "
     "Statistics would be serialized in JSON format inside the main dictionary "
     "under the statistics key. Available only if compiled in assert mode or "
     "with LLVM statistics explicitly enabled.",
-    false, shouldSerializeStats)
+    false)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, InlineObjCMethod, "objc-inlining",
-    "Whether ObjectiveC inlining is enabled, false otherwise.", true,
-    mayInlineObjCMethod)
+ANALYZER_OPTION(bool, MayInlineObjCMethod, "objc-inlining",
+                "Whether ObjectiveC inlining is enabled, false otherwise.",
+                true)
 
-ANALYZER_OPTION_GEN_FN(bool, PrunePaths, "prune-paths",
-                       "Whether irrelevant parts of a bug report path should "
-                       "be pruned out of the final output.",
-                       true, shouldPrunePaths)
+ANALYZER_OPTION(bool, ShouldPrunePaths, "prune-paths",
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, ConditionalizeStaticInitializers,
+ANALYZER_OPTION(
+    bool, ShouldConditionalizeStaticInitializers,
     "cfg-conditional-static-initializers",
     "Whether 'static' initializers should be in conditional logic in the CFG.",
-    true, shouldConditionalizeStaticInitializers)
+    true)
 
-ANALYZER_OPTION_GEN_FN(bool, SynthesizeBodies, "faux-bodies",
-                       "Whether the analyzer engine should synthesize fake "
-                       "bodies for well-known functions.",
-                       true, shouldSynthesizeBodies)
+ANALYZER_OPTION(bool, ShouldSynthesizeBodies, "faux-bodies",
+                true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, ElideConstructors, "elide-constructors",
+ANALYZER_OPTION(
+    bool, ShouldElideConstructors, "elide-constructors",
     "Whether elidable C++ copy-constructors and move-constructors should be "
     "actually elided during analysis. Both behaviors are allowed by the C++ "
     "standard, and the analyzer, like CodeGen, defaults to eliding. Starting "
     "with C++17 some elisions become mandatory, and in these cases the option "
     "will be ignored.",
-    true, shouldElideConstructors)
+    true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, InlineLambdas, "inline-lambdas",
+ANALYZER_OPTION(
+    bool, ShouldInlineLambdas, "inline-lambdas",
     "Whether lambdas should be inlined. Otherwise a sink node will be "
     "generated each time a LambdaExpr is visited.",
-    true, shouldInlineLambdas)
+    true)
 
-ANALYZER_OPTION_GEN_FN(bool, WidenLoops, "widen-loops",
-                       "Whether the analysis should try to widen loops.", false,
-                       shouldWidenLoops)
-
-ANALYZER_OPTION_GEN_FN(
-    bool, UnrollLoops, "unroll-loops",
-    "Whether the analysis should try to unroll loops with known bounds.", false,
-    shouldUnrollLoops)
+ANALYZER_OPTION(bool, ShouldWidenLoops, "widen-loops",
+                "Whether the analysis should try to widen loops.", false)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, DisplayNotesAsEvents, "notes-as-events",
+ANALYZER_OPTION(
+    bool, ShouldUnrollLoops, "unroll-loops",
+    "Whether the analysis should try to unroll loops with known bounds.", false)
+
+ANALYZER_OPTION(
+    bool, ShouldDisplayNotesAsEvents, "notes-as-events",
     "Whether the bug reporter should transparently treat extra note diagnostic "
     "pieces as event diagnostic pieces. Useful when the diagnostic consumer "
     "doesn't support the extra note pieces.",
-    false, shouldDisplayNotesAsEvents)
+    false)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, AggressivelySimplifyBinaryOperation,
+ANALYZER_OPTION(
+    bool, ShouldAggressivelySimplifyBinaryOperation,
     "aggressive-binary-operation-simplification",
     "Whether SValBuilder should rearrange comparisons and additive operations "
     "of symbolic expressions which consist of a sum of a symbol and a concrete "
     "integer into the format where symbols are on the left-hand side and the "
     "integer is on the right. This is only done if both symbols and both "
     "concrete integers are signed, greater than or equal to the quarter of the "
     "minimum value of the type and less than or equal to the quarter of the "
     "maximum value of that type. A + n <OP> B + m becomes A - B <OP> m - n, "
     "where A and B symbolic, n and m are integers. <OP> is any of '==', '!=', "
     "'<', '<=', '>', '>=', '+' or '-'. The rearrangement also happens with '-' "
     "instead of '+' on either or both side and also if any or both integers "
     "are missing.",
-    false, shouldAggressivelySimplifyBinaryOperation)
+    false)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, EagerlyAssume, "eagerly-assume",
+ANALYZER_OPTION(
+    bool, ShouldEagerlyAssume, "eagerly-assume",
     "Whether we should eagerly assume evaluations of conditionals, thus, "
     "bifurcating the path. This indicates how the engine should handle "
     "expressions such as: 'x = (y != 0)'. When this is true then the "
     "subexpression 'y != 0' will be eagerly assumed to be true or false, thus "
     "evaluating it to the integers 0 or 1 respectively. The upside is that "
     "this can increase analysis precision until we have a better way to lazily "
     "evaluate such logic. The downside is that it eagerly bifurcates paths.",
-    true, shouldEagerlyAssume)
+    true)
 
-ANALYZER_OPTION_GEN_FN(
-    bool, NaiveCTU, "experimental-enable-naive-ctu-analysis",
+ANALYZER_OPTION(
+    bool, IsNaiveCTUEnabled, "experimental-enable-naive-ctu-analysis",
     "Whether naive cross translation unit analysis is enabled. This is an "
     "experimental feature to inline functions from another translation units.",
-    false, naiveCTUEnabled)
+    false)
 
-ANALYZER_OPTION_GEN_FN(bool, DisplayMacroExpansions, "expand-macros",
-                       "Whether macros related to the bugpath should be "
-                       "expanded and included in the plist output.",
-                       false, shouldDisplayMacroExpansions)
+ANALYZER_OPTION(bool, ShouldDisplayMacroExpansions, "expand-macros",
+                false)
 
 //===----------------------------------------------------------------------===//
 // Unsinged analyzer options.
 //===----------------------------------------------------------------------===//
 
-ANALYZER_OPTION_GEN_FN(
+ANALYZER_OPTION(
     unsigned, AlwaysInlineSize, "ipa-always-inline-size",
     "The size of the functions (in basic blocks), which should be considered "
     "to be small enough to always inline.",
-    3, getAlwaysInlineSize)
+    3)
 
-ANALYZER_OPTION_GEN_FN(
+ANALYZER_OPTION(
     unsigned, GraphTrimInterval, "graph-trim-interval",
     "How often nodes in the ExplodedGraph should be recycled to save memory. "
     "To disable node reclamation, set the option to 0.",
-    1000, getGraphTrimInterval)
+    1000)
 
-ANALYZER_OPTION_GEN_FN(
+ANALYZER_OPTION(
     unsigned, MinCFGSizeTreatFunctionsAsLarge,
     "min-cfg-size-treat-functions-as-large",
     "The number of basic blocks a function needs to have to be considered "
     "large for the 'max-times-inline-large' config option.",
-    14, getMinCFGSizeTreatFunctionsAsLarge)
+    14)
 
-ANALYZER_OPTION_GEN_FN(unsigned, MaxSymbolComplexity, "max-symbol-complexity",
-                       "The maximum complexity of symbolic constraint.", 35,
-                       getMaxSymbolComplexity)
+ANALYZER_OPTION(unsigned, MaxSymbolComplexity, "max-symbol-complexity",
+                "The maximum complexity of symbolic constraint.", 35)
 
-ANALYZER_OPTION_GEN_FN(unsigned, MaxTimesInlineLarge, "max-times-inline-large",
-                       "The maximum times a large function could be inlined.",
-                       32, getMaxTimesInlineLarge)
+ANALYZER_OPTION(unsigned, MaxTimesInlineLarge, "max-times-inline-large",
+                "The maximum times a large function could be inlined.", 32)
 
-ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE(
+ANALYZER_OPTION_DEPENDS_ON_USER_MODE(
     unsigned, MaxInlinableSize, "max-inlinable-size",
     "The bound on the number of basic blocks in an inlined function.",
-    /* SHALLOW_VAL */ 4, /* DEEP_VAL */ 100, getMaxInlinableSize)
+    /* SHALLOW_VAL */ 4, /* DEEP_VAL */ 100)
 
-ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE(
+ANALYZER_OPTION_DEPENDS_ON_USER_MODE(
     unsigned, MaxNodesPerTopLevelFunction, "max-nodes",
     "The maximum number of nodes the analyzer can generate while exploring a "
     "top level function (for each exploded graph). 0 means no limit.",
-    /* SHALLOW_VAL */ 75000, /* DEEP_VAL */ 225000,
-    getMaxNodesPerTopLevelFunction)
+    /* SHALLOW_VAL */ 75000, /* DEEP_VAL */ 225000)
 
-ANALYZER_OPTION_GEN_FN(
+ANALYZER_OPTION(
     unsigned, RegionStoreSmallStructLimit, "region-store-small-struct-limit",
     "The largest number of fields a struct can have and still be considered "
     "small This is currently used to decide whether or not it is worth forcing "
     "a LazyCompoundVal on bind. To disable all small-struct-dependent "
     "behavior, set the option to 0.",
-    2, getRegionStoreSmallStructLimit)
+    2)
 
 //===----------------------------------------------------------------------===//
 // String analyzer options.
 //===----------------------------------------------------------------------===//
 
 ANALYZER_OPTION(StringRef, CTUDir, "ctu-dir",
                 "The directory containing the CTU related files.", "")
 
-ANALYZER_OPTION_GEN_FN(
-    StringRef, CTUIndexName, "ctu-index-name",
+ANALYZER_OPTION(StringRef, CTUIndexName, "ctu-index-name",
                 "the name of the file containing the CTU index of functions.",
-    "externalFnMap.txt", getCTUIndexName)
+                "externalFnMap.txt")
 
-ANALYZER_OPTION_GEN_FN(
+ANALYZER_OPTION(
     StringRef, ModelPath, "model-path",
     "The analyzer can inline an alternative implementation written in C at the "
     "call site if the called function's body is not available. This is a path "
     "where to look for those alternative implementations (called models).",
-    "", getModelPath)
-
-ANALYZER_OPTION(StringRef, UserMode, "mode",
-                "Controls the high-level analyzer mode, which influences the "
-                "default settings for some of the lower-level config options "
-                "(such as IPAMode). Value: \"deep\", \"shallow\".",
-                "deep")
+    "")
 
 ANALYZER_OPTION(
     StringRef, CXXMemberInliningMode, "c++-inlining",
     "Controls which C++ member functions will be considered for inlining. "
     "Value: \"constructors\", \"destructors\", \"methods\".",
     "destructors")
 
 ANALYZER_OPTION_DEPENDS_ON_USER_MODE(
     StringRef, IPAMode, "ipa",
     "Controls the mode of inter-procedural analysis. Value: \"none\", "
     "\"basic-inlining\", \"inlining\", \"dynamic\", \"dynamic-bifurcate\".",
     /* SHALLOW_VAL */ "inlining", /* DEEP_VAL */ "dynamic-bifurcate")
 
 ANALYZER_OPTION(
     StringRef, ExplorationStrategy, "exploration_strategy",
     "Value: \"dfs\", \"bfs\", \"unexplored_first\", "
     "\"unexplored_first_queue\", \"unexplored_first_location_queue\", "
     "\"bfs_block_dfs_contents\".",
     "unexplored_first_queue")
 
-#undef ANALYZER_OPTION_GEN_FN_DEPENDS_ON_USER_MODE
-#undef ANALYZER_OPTION_GEN_FN
 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 #undef ANALYZER_OPTION

lib/Frontend/CompilerInvocation.cpp

for (auto *A : Args.filtered(Group)) {
     } else {
       // Otherwise, add its value (for OPT_W_Joined and similar).
       for (const auto *Arg : A->getValues())
         Diagnostics.emplace_back(Arg);
     }
   }
 }
 
+static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
+                                 DiagnosticsEngine &Diags);
+
 static void getAllNoBuiltinFuncValues(ArgList &Args,
                                       std::vector<std::string> &Funcs) {
   SmallVector<const char *, 8> Values;
   for (const auto &Arg : Args) {
     const Option &O = Arg->getOption();
     if (O.matches(options::OPT_fno_builtin_)) {
       const char *FuncName = Arg->getValue();
       if (Builtin::Context::isBuiltinFunc(FuncName))
for (const auto &configVal : configVals) {
           << configVal;
         Success = false;
         break;
       }
       Opts.Config[key] = val;
     }
   }
 
+  parseAnalyzerConfigs(Opts, Diags);
+
   llvm::raw_string_ostream os(Opts.FullCompilerInvocation);
   for (unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
     if (i != 0)
       os << " ";
     os << Args.getArgString(i);
   }
   os.flush();
 
   return Success;
 }
 
+static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config,
+                                 StringRef OptionName, StringRef DefaultVal) {
+  return Config.insert({OptionName, DefaultVal}).first->second;
+}
+
+static void initOption(AnalyzerOptions::ConfigTable &Config,
+                       StringRef &OptionField, StringRef Name,
+                       StringRef DefaultVal) {
+  OptionField = getStringOption(Config, Name, DefaultVal);
+}
+
+static void initOption(AnalyzerOptions::ConfigTable &Config,
+                       bool &OptionField, StringRef Name, bool DefaultVal) {
+  // FIXME: We should emit a warning here if the value is something other than
+  // "true", "false", or the empty string (meaning the default value),
+  // but the AnalyzerOptions doesn't have access to a diagnostic engine.
+  OptionField = llvm::StringSwitch<bool>(getStringOption(Config, Name,
+                                               (DefaultVal ? "true" : "false")))
+      .Case("true", true)
+      .Case("false", false)
+      .Default(DefaultVal);
+}
+
+static void initOption(AnalyzerOptions::ConfigTable &Config,
+                       unsigned &OptionField, StringRef Name,
+                       unsigned DefaultVal) {
+  OptionField = DefaultVal;
+  bool HasFailed = getStringOption(Config, Name, std::to_string(DefaultVal))
+                     .getAsInteger(10, OptionField);
+  assert(!HasFailed && "analyzer-config option should be numeric");
+  (void)HasFailed;
+}
+
+static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
+                                 DiagnosticsEngine &Diags) {
+  // TODO: Emit warnings for incorrect options.
+  // TODO: There's no need to store the entire configtable, it'd be plenty
+  // enough tostore checker options.
+
+#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
+  initOption(AnOpts.Config, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);                \
+
+#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
+                                           SHALLOW_VAL, DEEP_VAL)              \
+  switch (AnOpts.getUserMode()) {                                              \
+  case UMK_Shallow:                                                            \
+    initOption(AnOpts.Config, AnOpts.NAME, CMDFLAG, SHALLOW_VAL);              \
+    break;                                                                     \
+  case UMK_Deep:                                                               \
+    initOption(AnOpts.Config, AnOpts.NAME, CMDFLAG, DEEP_VAL);                 \
+    break;                                                                     \
+  }                                                                            \
+
+#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
+#undef ANALYZER_OPTION
+#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
+}
+
 static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
   Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
   Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
   return true;
 }
 
 static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) {
   Opts.BlockCommandNames = Args.getAllArgValues(OPT_fcomment_block_commands);

lib/StaticAnalyzer/Checkers/DebugCheckers.cpp

void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
     SmallVector<const Table::MapEntryTy *, 32> Keys;
     for (Table::const_iterator I = Config.begin(), E = Config.end(); I != E;
          ++I)
       Keys.push_back(&*I);
     llvm::array_pod_sort(Keys.begin(), Keys.end(), compareEntry);
 
     llvm::errs() << "[config]\n";
     for (unsigned I = 0, E = Keys.size(); I != E; ++I)
-      llvm::errs() << Keys[I]->getKey() << " = " << Keys[I]->second << '\n';
+      llvm::errs() << Keys[I]->getKey() << " = "
+                   << (Keys[I]->second.empty() ? "\"\"" : Keys[I]->second)
+                   << '\n';
 
     llvm::errs() << "[stats]\n" << "num-entries = " << Keys.size() << '\n';
   }
 };
 }
 
 void ento::registerConfigDumper(CheckerManager &mgr) {
   mgr.registerChecker<ConfigDumper>();

lib/StaticAnalyzer/Checkers/MallocChecker.cpp

State = MallocUpdateRefState(C, NE, State, NE->isArray() ? AF_CXXNewArray
                                                            : AF_CXXNew, Target);
   State = addExtentSize(C, NE, State, Target);
   State = ProcessZeroAllocation(C, NE, 0, State, Target);
   C.addTransition(State);
 }
 
 void MallocChecker::checkPostStmt(const CXXNewExpr *NE,
                                   CheckerContext &C) const {
-  if (!C.getAnalysisManager().getAnalyzerOptions().mayInlineCXXAllocator())
+  if (!C.getAnalysisManager().getAnalyzerOptions().MayInlineCXXAllocator)
     processNewAllocation(NE, C, C.getSVal(NE));
 }
 
 void MallocChecker::checkNewAllocator(const CXXNewExpr *NE, SVal Target,
                                       CheckerContext &C) const {
   if (!C.wasInlined)
     processNewAllocation(NE, C, Target);
 }

lib/StaticAnalyzer/Core/AnalysisManager.cpp

 AnalysisManager::AnalysisManager(ASTContext &ASTCtx, DiagnosticsEngine &diags,
                                  const PathDiagnosticConsumers &PDC,
                                  StoreManagerCreator storemgr,
                                  ConstraintManagerCreator constraintmgr,
                                  CheckerManager *checkerMgr,
                                  AnalyzerOptions &Options,
                                  CodeInjector *injector)
     : AnaCtxMgr(
-          ASTCtx, Options.UnoptimizedCFG, Options.includeImplicitDtorsInCFG(),
-          /*AddInitializers=*/true, Options.includeTemporaryDtorsInCFG(),
-          Options.includeLifetimeInCFG(),
+          ASTCtx, Options.UnoptimizedCFG,
+          Options.ShouldIncludeImplicitDtorsInCFG,
+          /*AddInitializers=*/true,
+          Options.ShouldIncludeTemporaryDtorsInCFG,
+          Options.ShouldIncludeLifetimeInCFG,
           // Adding LoopExit elements to the CFG is a requirement for loop
           // unrolling.
-          Options.includeLoopExitInCFG() || Options.shouldUnrollLoops(),
-          Options.includeScopesInCFG(), Options.shouldSynthesizeBodies(),
-          Options.shouldConditionalizeStaticInitializers(),
-          /*addCXXNewAllocator=*/true, Options.includeRichConstructorsInCFG(),
-          Options.shouldElideConstructors(), injector),
+          Options.ShouldIncludeLoopExitInCFG ||
+            Options.ShouldUnrollLoops,
+          Options.ShouldIncludeScopesInCFG,
+          Options.ShouldSynthesizeBodies,
+          Options.ShouldConditionalizeStaticInitializers,
+          /*addCXXNewAllocator=*/true,
+          Options.ShouldIncludeRichConstructorsInCFG,
+          Options.ShouldElideConstructors, injector),
       Ctx(ASTCtx), Diags(diags), LangOpts(ASTCtx.getLangOpts()),
       PathConsumers(PDC), CreateStoreMgr(storemgr),
       CreateConstraintMgr(constraintmgr), CheckerMgr(checkerMgr),
       options(Options) {
   AnaCtxMgr.getCFGBuildOptions().setAllAlwaysAdd();
 }
 
 AnalysisManager::~AnalysisManager() {

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

#undef GET_CHECKERS
   for (StringRef CheckName : StaticAnalyzerChecks) {
     if (!CheckName.startswith("debug.") &&
         (IncludeExperimental || !CheckName.startswith("alpha.")))
       Result.push_back(CheckName);
   }
   return Result;
 }
 
-UserModeKind AnalyzerOptions::getUserMode() {
-  if (!UserMode.hasValue()) {
-    UserMode = getStringOption("mode", "deep");
-  }
-
-  auto K = llvm::StringSwitch<llvm::Optional<UserModeKind>>(*UserMode)
-    .Case("shallow", UMK_Shallow)
-    .Case("deep", UMK_Deep)
-    .Default(None);
-  assert(UserMode.hasValue() && "User mode is invalid.");
-  return K.getValue();
-}
-
 ExplorationStrategyKind
-AnalyzerOptions::getExplorationStrategy() {
-  if (!ExplorationStrategy.hasValue()) {
-    ExplorationStrategy = getStringOption("exploration_strategy",
-                                            "unexplored_first_queue");
-  }
+AnalyzerOptions::getExplorationStrategy() const {
   auto K =
     llvm::StringSwitch<llvm::Optional<ExplorationStrategyKind>>(
-                                                           *ExplorationStrategy)
+                                                            ExplorationStrategy)
           .Case("dfs", ExplorationStrategyKind::DFS)
           .Case("bfs", ExplorationStrategyKind::BFS)
           .Case("unexplored_first",
                 ExplorationStrategyKind::UnexploredFirst)
           .Case("unexplored_first_queue",
                 ExplorationStrategyKind::UnexploredFirstQueue)
           .Case("unexplored_first_location_queue",
                 ExplorationStrategyKind::UnexploredFirstLocationQueue)
           .Case("bfs_block_dfs_contents",
                 ExplorationStrategyKind::BFSBlockDFSContents)
           .Default(None);
   assert(K.hasValue() && "User mode is invalid.");
   return K.getValue();
 }
 
-IPAKind AnalyzerOptions::getIPAMode() {
-  if (!IPAMode.hasValue()) {
-    switch (getUserMode()) {
-    case UMK_Shallow:
-      IPAMode = getStringOption("ipa", "inlining");
-      break;
-    case UMK_Deep:
-      IPAMode = getStringOption("ipa", "dynamic-bifurcate");
-      break;
-    }
-  }
-  auto K = llvm::StringSwitch<llvm::Optional<IPAKind>>(*IPAMode)
+IPAKind AnalyzerOptions::getIPAMode() const {
+  auto K = llvm::StringSwitch<llvm::Optional<IPAKind>>(IPAMode)
           .Case("none", IPAK_None)
           .Case("basic-inlining", IPAK_BasicInlining)
           .Case("inlining", IPAK_Inlining)
           .Case("dynamic", IPAK_DynamicDispatch)
           .Case("dynamic-bifurcate", IPAK_DynamicDispatchBifurcate)
           .Default(None);
   assert(K.hasValue() && "IPA Mode is invalid.");
 
   return K.getValue();
 }
 
 bool
-AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind Param) {
-  if (!CXXMemberInliningMode.hasValue()) {
-    CXXMemberInliningMode = getStringOption("c++-inlining", "destructors");
-  }
-
+AnalyzerOptions::mayInlineCXXMemberFunction(
+                                          CXXInlineableMemberKind Param) const {
   if (getIPAMode() < IPAK_Inlining)
     return false;
 
   auto K =
     llvm::StringSwitch<llvm::Optional<CXXInlineableMemberKind>>(
-                                                         *CXXMemberInliningMode)
+                                                          CXXMemberInliningMode)
     .Case("constructors", CIMK_Constructors)
     .Case("destructors", CIMK_Destructors)
     .Case("methods", CIMK_MemberFunctions)
     .Case("none", CIMK_None)
     .Default(None);
 
   assert(K.hasValue() && "Invalid c++ member function inlining mode.");
 
   return *K >= Param;
 }
 
-StringRef AnalyzerOptions::getStringOption(StringRef OptionName,
-                                           StringRef DefaultVal) {
-  return Config.insert({OptionName, DefaultVal}).first->second;
-}
-
-static StringRef toString(bool B) { return (B ? "true" : "false"); }
-
-template <typename T>
-static StringRef toString(T) = delete;
-
-void AnalyzerOptions::initOption(Optional<StringRef> &V, StringRef Name,
-                                                         StringRef DefaultVal) {
-  if (V.hasValue())
-    return;
-
-  V = getStringOption(Name, DefaultVal);
-}
-
-void AnalyzerOptions::initOption(Optional<bool> &V, StringRef Name,
-                                                    bool DefaultVal) {
-  if (V.hasValue())
-    return;
-
-  // FIXME: We should emit a warning here if the value is something other than
-  // "true", "false", or the empty string (meaning the default value),
-  // but the AnalyzerOptions doesn't have access to a diagnostic engine.
-  V = llvm::StringSwitch<bool>(getStringOption(Name, toString(DefaultVal)))
-      .Case("true", true)
-      .Case("false", false)
-      .Default(DefaultVal);
-}
-
-void AnalyzerOptions::initOption(Optional<unsigned> &V, StringRef Name,
-                                                        unsigned DefaultVal) {
-  if (V.hasValue())
-    return;
-
-  V = DefaultVal;
-  bool HasFailed = getStringOption(Name, std::to_string(DefaultVal))
-                     .getAsInteger(10, *V);
-  assert(!HasFailed && "analyzer-config option should be numeric");
-  (void)HasFailed;
-}
-
 StringRef AnalyzerOptions::getCheckerStringOption(StringRef OptionName,
                                                   StringRef DefaultVal,
                                                   const CheckerBase *C,
                                                   bool SearchInParents) const {
   assert(C);
   // Search for a package option if the option for the checker is not specified
   // and search in parents is enabled.
   StringRef CheckerName = C->getTagDescription();

 bool AnalyzerOptions::getCheckerBooleanOption(StringRef Name, bool DefaultVal,
                                               const CheckerBase *C,
                                               bool SearchInParents) const {
   // FIXME: We should emit a warning here if the value is something other than
   // "true", "false", or the empty string (meaning the default value),
   // but the AnalyzerOptions doesn't have access to a diagnostic engine.
   assert(C);
   return llvm::StringSwitch<bool>(
-      getCheckerStringOption(Name, toString(DefaultVal), C, SearchInParents))
+      getCheckerStringOption(Name, DefaultVal ? "true" : "false", C,
+                             SearchInParents))
       .Case("true", true)
       .Case("false", false)
       .Default(DefaultVal);
 }
 
 int AnalyzerOptions::getCheckerIntegerOption(StringRef Name, int DefaultVal,
                                         const CheckerBase *C,
                                         bool SearchInParents) const {
   int Ret = DefaultVal;
   bool HasFailed = getCheckerStringOption(Name, std::to_string(DefaultVal), C,
                                           SearchInParents)
                      .getAsInteger(10, Ret);
   assert(!HasFailed && "analyzer-config option should be numeric");
   (void)HasFailed;
   return Ret;
 }
-
-StringRef AnalyzerOptions::getCTUDir() {
-  if (!CTUDir.hasValue()) {
-    CTUDir = getStringOption("ctu-dir", "");
-    if (!llvm::sys::fs::is_directory(*CTUDir))
-      CTUDir = "";
-  }
-  return CTUDir.getValue();
-}

lib/StaticAnalyzer/Core/BugReporter.cpp

if (AddPathEdges) {
     const Decl *D = CalleeLC->getDecl();
     addEdgeToPath(PD->getActivePath(), PrevLoc,
                   PathDiagnosticLocation::createBegin(D, SM));
   }
 
 
   // Finally, prune the diagnostic path of uninteresting stuff.
   if (!PD->path.empty()) {
-    if (R->shouldPrunePath() && Opts.shouldPrunePaths()) {
+    if (R->shouldPrunePath() && Opts.ShouldPrunePaths) {
       bool stillHasNotes =
           removeUnneededCalls(PD->getMutablePieces(), R, LCM);
       assert(stillHasNotes);
       (void)stillHasNotes;
     }
 
     // Redirect all call pieces to have valid locations.
     adjustCallLocations(PD->getMutablePieces());
if (!PD->path.empty()) {
 
     // Remove messages that are basically the same, and edges that may not
     // make sense.
     // We have to do this after edge optimization in the Extensive mode.
     removeRedundantMsgs(PD->getMutablePieces());
     removeEdgesToDefaultInitializers(PD->getMutablePieces());
   }
 
-  if (GenerateDiagnostics && Opts.shouldDisplayMacroExpansions())
+  if (GenerateDiagnostics && Opts.ShouldDisplayMacroExpansions)
     CompactMacroExpandedPieces(PD->getMutablePieces(), SM);
 
   return PD;
 }
 
 
 //===----------------------------------------------------------------------===//
 // Methods for BugType and subclasses.
while (TrimG.popNextReportGraph(ErrorGraph)) {
 
     BugReporterContext BRC(Reporter, ErrorGraph.BackMap);
 
     // Run all visitors on a given graph, once.
     std::unique_ptr<VisitorsDiagnosticsTy> visitorNotes =
         generateVisitorsDiagnostics(R, ErrorNode, BRC);
 
     if (R->isValid()) {
-      if (Opts.shouldCrosscheckWithZ3()) {
+      if (Opts.ShouldCrosscheckWithZ3) {
         // If crosscheck is enabled, remove all visitors, add the refutation
         // visitor and check again
         R->clearVisitors();
         R->addVisitor(llvm::make_unique<FalsePositiveRefutationBRVisitor>());
 
         // We don't overrite the notes inserted by other visitors because the
         // refutation manager does not add any new note to the path
         generateVisitorsDiagnostics(R, ErrorGraph.ErrorNode, BRC);
if (PD->path.empty()) {
       auto piece = llvm::make_unique<PathDiagnosticEventPiece>(
         L, report->getDescription());
       for (SourceRange Range : report->getRanges())
         piece->addRange(Range);
       PD->setEndOfPath(std::move(piece));
     }
 
     PathPieces &Pieces = PD->getMutablePieces();
-    if (getAnalyzerOptions().shouldDisplayNotesAsEvents()) {
+    if (getAnalyzerOptions().ShouldDisplayNotesAsEvents) {
       // For path diagnostic consumers that don't support extra notes,
       // we may optionally convert those to path notes.
       for (auto I = report->getNotes().rbegin(),
            E = report->getNotes().rend(); I != E; ++I) {
         PathDiagnosticNotePiece *Piece = I->get();
         auto ConvertedPiece = std::make_shared<PathDiagnosticEventPiece>(
           Piece->getLocation(), Piece->getString());
         for (const auto &R: Piece->getRanges())
if (Out->empty())
     return Out;
 
   MaxValidBugClassSize.updateMax(bugReports.size());
 
   // Examine the report and see if the last piece is in a header. Reset the
   // report location to the last piece in the main source file.
   AnalyzerOptions &Opts = getAnalyzerOptions();
   for (auto const &P : *Out)
-    if (Opts.shouldReportIssuesInMainSourceFile() && !Opts.AnalyzeAll)
+    if (Opts.ShouldReportIssuesInMainSourceFile && !Opts.AnalyzeAll)
       P.second->resetDiagnosticLocationToMainFile();
 
   return Out;
 }
 
 void BugReporter::EmitBasicReport(const Decl *DeclWithIssue,
                                   const CheckerBase *Checker,
                                   StringRef Name, StringRef Category,

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
     return nullptr;
   }
 
   static void addMacroVisitorIfNecessary(
         const ExplodedNode *N, const MemRegion *R,
         bool EnableNullFPSuppression, BugReport &BR,
         const SVal V) {
     AnalyzerOptions &Options = N->getState()->getAnalysisManager().options;
-    if (EnableNullFPSuppression && Options.shouldSuppressNullReturnPaths()
-          && V.getAs<Loc>())
+    if (EnableNullFPSuppression &&
+        Options.ShouldSuppressNullReturnPaths && V.getAs<Loc>())
       BR.addVisitor(llvm::make_unique<MacroNullReturnSuppressionVisitor>(
               R->getAs<SubRegion>(), V));
   }
 
   void* getTag() const {
     static int Tag = 0;
     return static_cast<void *>(&Tag);
   }
static void addVisitorIfNecessary(const ExplodedNode *Node, const Stmt *S,
     if (cast<Expr>(S)->isGLValue())
       if (Optional<Loc> LValue = RetVal.getAs<Loc>())
         RetVal = State->getSVal(*LValue);
 
     // See if the return value is NULL. If so, suppress the report.
     AnalyzerOptions &Options = State->getAnalysisManager().options;
 
     bool EnableNullFPSuppression = false;
-    if (InEnableNullFPSuppression && Options.shouldSuppressNullReturnPaths())
+    if (InEnableNullFPSuppression &&
+        Options.ShouldSuppressNullReturnPaths)
       if (Optional<Loc> RetLoc = RetVal.getAs<Loc>())
         EnableNullFPSuppression = State->isNull(*RetLoc).isConstrainedTrue();
 
     BR.markInteresting(CalleeContext);
     BR.addVisitor(llvm::make_unique<ReturnVisitor>(CalleeContext,
                                                    EnableNullFPSuppression,
                                                    Options));
   }
visitNodeInitial(const ExplodedNode *N,
 
     if (State->isNull(V).isConstrainedTrue()) {
       if (V.getAs<Loc>()) {
 
         // If we have counter-suppression enabled, make sure we keep visiting
         // future nodes. We want to emit a path note as well, in case
         // the report is resurrected as valid later on.
         if (EnableNullFPSuppression &&
-            Options.shouldAvoidSuppressingNullArgumentPaths())
+            Options.ShouldAvoidSuppressingNullArgumentPaths)
           Mode = MaybeUnsuppress;
 
         if (RetE->getType()->isObjCObjectPointerType()) {
           Out << "Returning nil";
         } else {
           Out << "Returning null pointer";
         }
       } else {
visitNodeInitial(const ExplodedNode *N,
 
     return std::make_shared<PathDiagnosticEventPiece>(L, Out.str());
   }
 
   std::shared_ptr<PathDiagnosticPiece>
   visitNodeMaybeUnsuppress(const ExplodedNode *N,
                            BugReporterContext &BRC, BugReport &BR) {
 #ifndef NDEBUG
-    assert(Options.shouldAvoidSuppressingNullArgumentPaths());
+    assert(Options.ShouldAvoidSuppressingNullArgumentPaths);
 #endif
 
     // Are we at the entry node for this call?
     Optional<CallEnter> CE = N->getLocationAs<CallEnter>();
     if (!CE)
       return nullptr;
 
     if (CE->getCalleeContext() != StackFrame)
TrackConstraintBRVisitor::VisitNode(const ExplodedNode *N,
   return nullptr;
 }
 
 SuppressInlineDefensiveChecksVisitor::
 SuppressInlineDefensiveChecksVisitor(DefinedSVal Value, const ExplodedNode *N)
     : V(Value) {
   // Check if the visitor is disabled.
   AnalyzerOptions &Options = N->getState()->getAnalysisManager().options;
-  if (!Options.shouldSuppressInlinedDefensiveChecks())
+  if (!Options.ShouldSuppressInlinedDefensiveChecks)
     IsSatisfied = true;
 
   assert(N->getState()->isNull(V).isConstrainedTrue() &&
          "The visitor only tracks the cases where V is constrained to 0");
 }
 
 void SuppressInlineDefensiveChecksVisitor::Profile(
     llvm::FoldingSetNodeID &ID) const {
void LikelyFalsePositiveSuppressionBRVisitor::finalizeVisitor(
   AnalyzerOptions &Options = BRC.getAnalyzerOptions();
   const Decl *D = N->getLocationContext()->getDecl();
 
   if (AnalysisDeclContext::isInStdNamespace(D)) {
     // Skip reports within the 'std' namespace. Although these can sometimes be
     // the user's fault, we currently don't report them very well, and
     // Note that this will not help for any other data structure libraries, like
     // TR1, Boost, or llvm/ADT.
-    if (Options.shouldSuppressFromCXXStandardLibrary()) {
+    if (Options.ShouldSuppressFromCXXStandardLibrary) {
       BR.markInvalid(getTag(), nullptr);
       return;
     } else {
       // If the complete 'std' suppression is not enabled, suppress reports
       // from the 'std' namespace that are known to produce false positives.
 
       // The analyzer issues a false use-after-free when std::list::pop_front
       // or std::list::pop_back are called multiple times because we cannot

lib/StaticAnalyzer/Core/CallEvent.cpp

if (Body) {
     const Decl* Decl = AD->getDecl();
     return RuntimeDefinition(Decl);
   }
 
   SubEngine *Engine = getState()->getStateManager().getOwningEngine();
   AnalyzerOptions &Opts = Engine->getAnalysisManager().options;
 
   // Try to get CTU definition only if CTUDir is provided.
-  if (!Opts.naiveCTUEnabled())
+  if (!Opts.IsNaiveCTUEnabled)
     return {};
 
   cross_tu::CrossTranslationUnitContext &CTUCtx =
       *Engine->getCrossTranslationUnitContext();
   llvm::Expected<const FunctionDecl *> CTUDeclOrError =
-      CTUCtx.getCrossTUDefinition(FD, Opts.getCTUDir(), Opts.getCTUIndexName());
+      CTUCtx.getCrossTUDefinition(FD, Opts.CTUDir,
+                                  Opts.CTUIndexName);
 
   if (!CTUDeclOrError) {
     handleAllErrors(CTUDeclOrError.takeError(),
                     [&](const cross_tu::IndexError &IE) {
                       CTUCtx.emitCrossTUDiagnostics(IE);
                     });
     return {};
   }

lib/StaticAnalyzer/Core/ExprEngine.cpp

: CTU(CTU), AMgr(mgr),
       Engine(*this, FS, mgr.getAnalyzerOptions()), G(Engine.getGraph()),
       StateMgr(getContext(), mgr.getStoreManagerCreator(),
                mgr.getConstraintManagerCreator(), G.getAllocator(),
                this),
       SymMgr(StateMgr.getSymbolManager()),
       svalBuilder(StateMgr.getSValBuilder()), ObjCNoRet(mgr.getASTContext()),
       BR(mgr, *this),
       VisitedCallees(VisitedCalleesIn), HowToInline(HowToInlineIn) {
-  unsigned TrimInterval = mgr.options.getGraphTrimInterval();
+  unsigned TrimInterval = mgr.options.GraphTrimInterval;
   if (TrimInterval != 0) {
     // Enable eager node reclaimation when constructing the ExplodedGraph.
     G.enableNodeReclamation(TrimInterval);
   }
 }
 
 ExprEngine::~ExprEngine() {
   BR.FlushReports();
void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                 S->getBeginLoc(),
                                 "Error evaluating end of the loop");
   ExplodedNodeSet Dst;
   Dst.Add(Pred);
   NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
   ProgramStateRef NewState = Pred->getState();
 
-  if(AMgr.options.shouldUnrollLoops())
+  if(AMgr.options.ShouldUnrollLoops)
     NewState = processLoopEnd(S, NewState);
 
   LoopExit PP(S, Pred->getLocationContext());
   Bldr.generateNode(PP, NewState, Pred);
   // Enqueue the new nodes onto the work list.
   Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
 }
 

 void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE,
                                      ExplodedNode *Pred) {
   ExplodedNodeSet Dst;
   AnalysisManager &AMgr = getAnalysisManager();
   AnalyzerOptions &Opts = AMgr.options;
   // TODO: We're not evaluating allocators for all cases just yet as
   // we're not handling the return value correctly, which causes false
   // positives when the alpha.cplusplus.NewDeleteLeaks check is on.
-  if (Opts.mayInlineCXXAllocator())
+  if (Opts.MayInlineCXXAllocator)
     VisitCXXNewAllocatorCall(NE, Pred, Dst);
   else {
     NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
     const LocationContext *LCtx = Pred->getLocationContext();
     PostImplicitCall PP(NE->getOperatorNew(), NE->getBeginLoc(), LCtx);
     Bldr.generateNode(PP, Pred->getState(), Pred);
   }
   Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);

 }
 
 void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
                                            ExplodedNodeSet &PreVisit,
                                            ExplodedNodeSet &Dst) {
   // This is a fallback solution in case we didn't have a construction
   // context when we were constructing the temporary. Otherwise the map should
   // have been populated there.
-  if (!getAnalysisManager().options.includeTemporaryDtorsInCFG()) {
+  if (!getAnalysisManager().options.ShouldIncludeTemporaryDtorsInCFG) {
     // In case we don't have temporary destructors in the CFG, do not mark
     // the initialization - we would otherwise never clean it up.
     Dst = PreVisit;
     return;
   }
   StmtNodeBuilder StmtBldr(PreVisit, Dst, *currBldrCtx);
   for (ExplodedNode *Node : PreVisit) {
     ProgramStateRef State = Node->getState();
switch (S->getStmtClass()) {
 
     case Stmt::BlockExprClass:
       Bldr.takeNodes(Pred);
       VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
       Bldr.addNodes(Dst);
       break;
 
     case Stmt::LambdaExprClass:
-      if (AMgr.options.shouldInlineLambdas()) {
+      if (AMgr.options.ShouldInlineLambdas) {
         Bldr.takeNodes(Pred);
         VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
         Bldr.addNodes(Dst);
       } else {
         const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
         Engine.addAbortedBlock(node, currBldrCtx->getBlock());
       }
       break;
case Stmt::BinaryOperatorClass: {
                           state->BindExpr(B, Pred->getLocationContext(),
                                           state->getSVal(B->getRHS(),
                                                   Pred->getLocationContext())));
         break;
       }
 
       Bldr.takeNodes(Pred);
 
-      if (AMgr.options.shouldEagerlyAssume() &&
+      if (AMgr.options.ShouldEagerlyAssume &&
           (B->isRelationalOp() || B->isEqualityOp())) {
         ExplodedNodeSet Tmp;
         VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
         evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
       }
       else
         VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
 
case Stmt::StmtExprClass: {
                                                   Pred->getLocationContext())));
       }
       break;
     }
 
     case Stmt::UnaryOperatorClass: {
       Bldr.takeNodes(Pred);
       const auto *U = cast<UnaryOperator>(S);
-      if (AMgr.options.shouldEagerlyAssume() && (U->getOpcode() == UO_LNot)) {
+      if (AMgr.options.ShouldEagerlyAssume && (U->getOpcode() == UO_LNot)) {
         ExplodedNodeSet Tmp;
         VisitUnaryOperator(U, Pred, Tmp);
         evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
       }
       else
         VisitUnaryOperator(U, Pred, Dst);
       Bldr.addNodes(Dst);
       break;

 
 /// Block entrance.  (Update counters).
 void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
                                          NodeBuilderWithSinks &nodeBuilder,
                                          ExplodedNode *Pred) {
   PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
   // If we reach a loop which has a known bound (and meets
   // other constraints) then consider completely unrolling it.
-  if(AMgr.options.shouldUnrollLoops()) {
+  if(AMgr.options.ShouldUnrollLoops) {
     unsigned maxBlockVisitOnPath = AMgr.options.maxBlockVisitOnPath;
     const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminator();
     if (Term) {
       ProgramStateRef NewState = updateLoopStack(Term, AMgr.getASTContext(),
                                                  Pred, maxBlockVisitOnPath);
       if (NewState != Pred->getState()) {
         ExplodedNode *UpdatedNode = nodeBuilder.generateNode(NewState, Pred);
         if (!UpdatedNode)
           return;
         Pred = UpdatedNode;
       }
     }
     // Is we are inside an unrolled loop then no need the check the counters.
     if(isUnrolledState(Pred->getState()))
       return;
   }
 
   // If this block is terminated by a loop and it has already been visited the
   // maximum number of times, widen the loop.
   unsigned int BlockCount = nodeBuilder.getContext().blockCount();
   if (BlockCount == AMgr.options.maxBlockVisitOnPath - 1 &&
-      AMgr.options.shouldWidenLoops()) {
+      AMgr.options.ShouldWidenLoops) {
     const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminator();
     if (!(Term &&
           (isa<ForStmt>(Term) || isa<WhileStmt>(Term) || isa<DoStmt>(Term))))
       return;
     // Widen.
     const LocationContext *LCtx = Pred->getLocationContext();
     ProgramStateRef WidenedState =
         getWidenedLoopState(Pred->getState(), LCtx, BlockCount, Term);
if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // you can even do things with it. We simply pretend
     assert(Ex->isGLValue() || VD->getType()->isVoidType());
     const LocationContext *LocCtxt = Pred->getLocationContext();
     const Decl *D = LocCtxt->getDecl();
     const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
     const auto *DeclRefEx = dyn_cast<DeclRefExpr>(Ex);
     Optional<std::pair<SVal, QualType>> VInfo;
 
-    if (AMgr.options.shouldInlineLambdas() && DeclRefEx &&
+    if (AMgr.options.ShouldInlineLambdas && DeclRefEx &&
         DeclRefEx->refersToEnclosingVariableOrCapture() && MD &&
         MD->getParent()->isLambda()) {
       // Lookup the field of the lambda.
       const CXXRecordDecl *CXXRec = MD->getParent();
       llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
       FieldDecl *LambdaThisCaptureField;
       CXXRec->getCaptureFields(LambdaCaptureFields, LambdaThisCaptureField);
 

lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

case ConstructionContext::SimpleConstructorInitializerKind: {
 
       QualType Ty = Field->getType();
       FieldVal = makeZeroElementRegion(State, FieldVal, Ty,
                                        CallOpts.IsArrayCtorOrDtor);
       State = addObjectUnderConstruction(State, Init, LCtx, FieldVal);
       return std::make_pair(State, FieldVal);
     }
     case ConstructionContext::NewAllocatedObjectKind: {
-      if (AMgr.getAnalyzerOptions().mayInlineCXXAllocator()) {
+      if (AMgr.getAnalyzerOptions().MayInlineCXXAllocator) {
         const auto *NECC = cast<NewAllocatedObjectConstructionContext>(CC);
         const auto *NE = NECC->getCXXNewExpr();
         SVal V = *getObjectUnderConstruction(State, NE, LCtx);
         if (const SubRegion *MR =
                 dyn_cast_or_null<SubRegion>(V.getAsRegion())) {
           if (NE->isArray()) {
             // TODO: In fact, we need to call the constructor for every
             // allocated element, not just the first one!
case ConstructionContext::CXX17ElidedCopyReturnedValueKind: {
         // think that this object immediately goes out of scope?
         CallOpts.IsTemporaryCtorOrDtor = true;
         SVal V = loc::MemRegionVal(MRMgr.getCXXTempObjectRegion(E, LCtx));
         return std::make_pair(State, V);
       }
       llvm_unreachable("Unhandled return value construction context!");
     }
     case ConstructionContext::ElidedTemporaryObjectKind: {
-      assert(AMgr.getAnalyzerOptions().shouldElideConstructors());
+      assert(AMgr.getAnalyzerOptions().ShouldElideConstructors);
       const auto *TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);
       const CXXBindTemporaryExpr *BTE = TCC->getCXXBindTemporaryExpr();
       const MaterializeTemporaryExpr *MTE = TCC->getMaterializedTemporaryExpr();
       const CXXConstructExpr *CE = TCC->getConstructorAfterElision();
 
       // Support pre-C++17 copy elision. We'll have the elidable copy
       // constructor in the AST and in the CFG, but we'll skip it
       // and construct directly into the final object. This call
void ExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
   FunctionDecl *FD = CNE->getOperatorNew();
 
   bool IsStandardGlobalOpNewFunction =
       FD->isReplaceableGlobalAllocationFunction();
 
   ProgramStateRef State = Pred->getState();
 
   // Retrieve the stored operator new() return value.
-  if (AMgr.getAnalyzerOptions().mayInlineCXXAllocator()) {
+  if (AMgr.getAnalyzerOptions().MayInlineCXXAllocator) {
     symVal = *getObjectUnderConstruction(State, CNE, LCtx);
     State = finishObjectConstruction(State, CNE, LCtx);
   }
 
   // We assume all standard global 'operator new' functions allocate memory in
   // heap. We realize this is an approximation that might not correctly model
   // a custom global allocator.
   if (symVal.isUnknown()) {
     if (IsStandardGlobalOpNewFunction)
       symVal = svalBuilder.getConjuredHeapSymbolVal(CNE, LCtx, blockCount);
     else
       symVal = svalBuilder.conjureSymbolVal(nullptr, CNE, LCtx, CNE->getType(),
                                             blockCount);
   }
 
   CallEventManager &CEMgr = getStateManager().getCallEventManager();
   CallEventRef<CXXAllocatorCall> Call =
     CEMgr.getCXXAllocatorCall(CNE, State, LCtx);
 
-  if (!AMgr.getAnalyzerOptions().mayInlineCXXAllocator()) {
+  if (!AMgr.getAnalyzerOptions().MayInlineCXXAllocator) {
     // Invalidate placement args.
     // FIXME: Once we figure out how we want allocators to work,
     // we should be using the usual pre-/(default-)eval-/post-call checks here.
     State = Call->invalidateRegions(blockCount);
     if (!State)
       return;
 
     // If this allocation function is not declared as non-throwing, failures

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

for (ExplodedNodeSet::iterator I = CleanedNodes.begin(),
     }
     ExplodedNodeSet Dst;
     if (const ObjCMethodCall *Msg = dyn_cast<ObjCMethodCall>(Call)) {
       getCheckerManager().runCheckersForPostObjCMessage(Dst, DstPostCall, *Msg,
                                                         *this,
                                                         /*WasInlined=*/true);
     } else if (CE &&
                !(isa<CXXNewExpr>(CE) && // Called when visiting CXXNewExpr.
-                 AMgr.getAnalyzerOptions().mayInlineCXXAllocator())) {
+                 AMgr.getAnalyzerOptions().MayInlineCXXAllocator)) {
       getCheckerManager().runCheckersForPostStmt(Dst, DstPostCall, CE,
                                                  *this, /*WasInlined=*/true);
     } else {
       Dst.insert(DstPostCall);
     }
 
     // Enqueue the next element in the block.
     for (ExplodedNodeSet::iterator PSI = Dst.begin(), PSE = Dst.end();
if (const StackFrameContext *SFC = dyn_cast<StackFrameContext>(LCtx)) {
         ++StackDepth;
         LCtx = LCtx->getParent();
         continue;
       }
 
       // Do not count the small functions when determining the stack depth.
       AnalysisDeclContext *CalleeADC = AMgr.getAnalysisDeclContext(DI);
       const CFG *CalleeCFG = CalleeADC->getCFG();
-      if (CalleeCFG->getNumBlockIDs() > AMgr.options.getAlwaysInlineSize())
+      if (CalleeCFG->getNumBlockIDs() > AMgr.options.AlwaysInlineSize)
         ++StackDepth;
     }
     LCtx = LCtx->getParent();
   }
 }
 
 // The GDM component containing the dynamic dispatch bifurcation info. When
 // the exact type of the receiver is not known, we want to explore both paths -
case CE_CXXConstructor: {
 
     const CXXConstructExpr *CtorExpr = Ctor.getOriginExpr();
 
     auto CCE = getCurrentCFGElement().getAs<CFGConstructor>();
     const ConstructionContext *CC = CCE ? CCE->getConstructionContext()
                                         : nullptr;
 
     if (CC && isa<NewAllocatedObjectConstructionContext>(CC) &&
-        !Opts.mayInlineCXXAllocator())
+        !Opts.MayInlineCXXAllocator)
       return CIP_DisallowedOnce;
 
     // FIXME: We don't handle constructors or destructors for arrays properly.
     // Even once we do, we still need to be careful about implicitly-generated
     // initializers for array fields in default move/copy constructors.
     // We still allow construction into ElementRegion targets when they don't
     // represent array elements.
     if (CallOpts.IsArrayCtorOrDtor)
case CE_CXXConstructor: {
     // also enabled.
     if (!Opts.mayInlineCXXMemberFunction(CIMK_Destructors))
       return CIP_DisallowedAlways;
 
     if (CtorExpr->getConstructionKind() == CXXConstructExpr::CK_Complete) {
       // If we don't handle temporary destructors, we shouldn't inline
       // their constructors.
       if (CallOpts.IsTemporaryCtorOrDtor &&
-          !Opts.includeTemporaryDtorsInCFG())
+          !Opts.ShouldIncludeTemporaryDtorsInCFG)
         return CIP_DisallowedOnce;
 
       // If we did not find the correct this-region, it would be pointless
       // to inline the constructor. Instead we will simply invalidate
       // the fake temporary target.
       if (CallOpts.IsCtorOrDtorWithImproperlyModeledTargetRegion)
         return CIP_DisallowedOnce;
 
case CE_CXXDestructor: {
     assert(ADC->getCFGBuildOptions().AddImplicitDtors && "No CFG destructors");
     (void)ADC;
 
     // FIXME: We don't handle constructors or destructors for arrays properly.
     if (CallOpts.IsArrayCtorOrDtor)
       return CIP_DisallowedOnce;
 
     // Allow disabling temporary destructor inlining with a separate option.
-    if (CallOpts.IsTemporaryCtorOrDtor && !Opts.mayInlineCXXTemporaryDtors())
+    if (CallOpts.IsTemporaryCtorOrDtor &&
+        !Opts.MayInlineCXXTemporaryDtors)
       return CIP_DisallowedOnce;
 
     // If we did not find the correct this-region, it would be pointless
     // to inline the destructor. Instead we will simply invalidate
     // the fake temporary target.
     if (CallOpts.IsCtorOrDtorWithImproperlyModeledTargetRegion)
       return CIP_DisallowedOnce;
     break;
   }
   case CE_CXXAllocator:
-    if (Opts.mayInlineCXXAllocator())
+    if (Opts.MayInlineCXXAllocator)
       break;
     // Do not inline allocators until we model deallocators.
     // This is unfortunate, but basically necessary for smart pointers and such.
     return CIP_DisallowedAlways;
   case CE_ObjCMessage:
-    if (!Opts.mayInlineObjCMethod())
+    if (!Opts.MayInlineObjCMethod)
       return CIP_DisallowedAlways;
     if (!(Opts.getIPAMode() == IPAK_DynamicDispatch ||
           Opts.getIPAMode() == IPAK_DynamicDispatchBifurcate))
       return CIP_DisallowedAlways;
     break;
   }
 
   return CIP_Allowed;
static bool mayInlineDecl(AnalysisManager &AMgr,
   if (CallEvent::isVariadic(CalleeADC->getDecl()))
     return false;
 
   // Check certain C++-related inlining policies.
   ASTContext &Ctx = CalleeADC->getASTContext();
   if (Ctx.getLangOpts().CPlusPlus) {
     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeADC->getDecl())) {
       // Conditionally control the inlining of template functions.
-      if (!Opts.mayInlineTemplateFunctions())
+      if (!Opts.MayInlineTemplateFunctions)
         if (FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate)
           return false;
 
       // Conditionally control the inlining of C++ standard library functions.
-      if (!Opts.mayInlineCXXStandardLibrary())
+      if (!Opts.MayInlineCXXStandardLibrary)
         if (Ctx.getSourceManager().isInSystemHeader(FD->getLocation()))
           if (AnalysisDeclContext::isInStdNamespace(FD))
             return false;
 
       // Conditionally control the inlining of methods on objects that look
       // like C++ containers.
-      if (!Opts.mayInlineCXXContainerMethods())
+      if (!Opts.MayInlineCXXContainerMethods)
         if (!AMgr.isInCodeFile(FD->getLocation()))
           if (isContainerMethod(Ctx, FD))
             return false;
 
       // Conditionally control the inlining of the destructor of C++ shared_ptr.
       // We don't currently do a good job modeling shared_ptr because we can't
       // see the reference count, so treating as opaque is probably the best
       // idea.
-      if (!Opts.mayInlineCXXSharedPtrDtor())
+      if (!Opts.MayInlineCXXSharedPtrDtor)
         if (isCXXSharedPtrDtor(FD))
           return false;
     }
   }
 
   // It is possible that the CFG cannot be constructed.
   // Be safe, and check if the CalleeCFG is valid.
   const CFG *CalleeCFG = CalleeADC->getCFG();
   if (!CalleeCFG)
     return false;
 
   // Do not inline large functions.
-  if (CalleeCFG->getNumBlockIDs() > Opts.getMaxInlinableSize())
+  if (CalleeCFG->getNumBlockIDs() > Opts.MaxInlinableSize)
     return false;
 
   // It is possible that the live variables analysis cannot be
   // run.  If so, bail out.
   if (!CalleeADC->getAnalysis<RelaxedLiveVariables>())
     return false;
 
   return true;
bool ExprEngine::shouldInlineCall(const CallEvent &Call, const Decl *D,
 
   const CFG *CalleeCFG = CalleeADC->getCFG();
 
   // Do not inline if recursive or we've reached max stack frame count.
   bool IsRecursive = false;
   unsigned StackDepth = 0;
   examineStackFrames(D, Pred->getLocationContext(), IsRecursive, StackDepth);
   if ((StackDepth >= Opts.InlineMaxStackDepth) &&
-      ((CalleeCFG->getNumBlockIDs() > Opts.getAlwaysInlineSize())
+      ((CalleeCFG->getNumBlockIDs() > Opts.AlwaysInlineSize)
        || IsRecursive))
     return false;
 
   // Do not inline large functions too many times.
   if ((Engine.FunctionSummaries->getNumTimesInlined(D) >
-       Opts.getMaxTimesInlineLarge()) &&
+       Opts.MaxTimesInlineLarge) &&
        CalleeCFG->getNumBlockIDs() >=
-       Opts.getMinCFGSizeTreatFunctionsAsLarge()) {
+       Opts.MinCFGSizeTreatFunctionsAsLarge) {
     NumReachedInlineCountMax++;
     return false;
   }
 
   if (HowToInline == Inline_Minimal &&
-      (CalleeCFG->getNumBlockIDs() > Opts.getAlwaysInlineSize()
+      (CalleeCFG->getNumBlockIDs() > Opts.AlwaysInlineSize
       || IsRecursive))
     return false;
 
   return true;
 }
 
 static bool isTrivialObjectAssignment(const CallEvent &Call) {
   const CXXInstanceCall *ICall = dyn_cast<CXXInstanceCall>(&Call);

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

if (report.empty()) {
     llvm::errs() << "warning: no diagnostics generated for main file.\n";
     return;
   }
 
   // Create a path for the target HTML file.
   int FD;
   SmallString<128> Model, ResultPath;
 
-  if (!AnalyzerOpts.shouldWriteStableReportFilename()) {
+  if (!AnalyzerOpts.ShouldWriteStableReportFilename) {
       llvm::sys::path::append(Model, Directory, "report-%%%%%%.html");
       if (std::error_code EC =
           llvm::sys::fs::make_absolute(Model)) {
           llvm::errs() << "warning: could not make '" << Model
                        << "' absolute: " << EC.message() << '\n';
         return;
       }
       if (std::error_code EC =

lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

static void printBugPath(llvm::raw_ostream &o, const FIDMap& FM,
 
   o << "   <array>\n";
 
   for (PathPieces::const_iterator E = Path.end(); I != E; ++I)
     Printer.ReportDiag(o, **I);
 
   o << "   </array>\n";
 
-  if (!AnOpts.shouldDisplayMacroExpansions())
+  if (!AnOpts.ShouldDisplayMacroExpansions)
     return;
 
   o << "   <key>macro_expansions</key>\n"
        "   <array>\n";
   Printer.ReportMacroExpansions(o, /* indent */ 4);
   o << "   </array>\n";
 }
 
void PlistDiagnostics::FlushDiagnosticsImpl(
   o << " </array>\n";
 
   o << " <key>files</key>\n"
        " <array>\n";
   for (FileID FID : Fids)
     EmitString(o << "  ", SM.getFileEntryForID(FID)->getName()) << '\n';
   o << " </array>\n";
 
-  if (llvm::AreStatisticsEnabled() && AnOpts.shouldSerializeStats()) {
+  if (llvm::AreStatisticsEnabled() && AnOpts.ShouldSerializeStats) {
     o << " <key>statistics</key>\n";
     std::string stats;
     llvm::raw_string_ostream os(stats);
     llvm::PrintStatisticsJSON(os);
     os.flush();
     EmitString(o, html::EscapeText(stats)) << '\n';
   }
 
   // Finish.
   o << "</dict>\n</plist>";
 }

lib/StaticAnalyzer/Core/RegionStore.cpp

 public:
   RegionStoreManager(ProgramStateManager& mgr, const RegionStoreFeatures &f)
     : StoreManager(mgr), Features(f),
       RBFactory(mgr.getAllocator()), CBFactory(mgr.getAllocator()),
       SmallStructLimit(0) {
     if (SubEngine *Eng = StateMgr.getOwningEngine()) {
       AnalyzerOptions &Options = Eng->getAnalysisManager().options;
       SmallStructLimit =
-        Options.getRegionStoreSmallStructLimit();
+        Options.RegionStoreSmallStructLimit;
     }
   }
 
 
   /// setImplicitDefaultValue - Set the default binding for the provided
   ///  MemRegion to the value implicitly defined for compound literals when
   ///  the value is not specified.
   RegionBindingsRef setImplicitDefaultValue(RegionBindingsConstRef B,

lib/StaticAnalyzer/Core/SValBuilder.cpp

SVal SValBuilder::makeSymExprValNN(BinaryOperator::Opcode Op,
                                    QualType ResultTy) {
   const SymExpr *symLHS = LHS.getAsSymExpr();
   const SymExpr *symRHS = RHS.getAsSymExpr();
 
   // TODO: When the Max Complexity is reached, we should conjure a symbol
   // instead of generating an Unknown value and propagate the taint info to it.
   const unsigned MaxComp = StateMgr.getOwningEngine()
                                ->getAnalysisManager()
-                               .options.getMaxSymbolComplexity();
+                               .options.MaxSymbolComplexity;
 
   if (symLHS && symRHS &&
       (symLHS->computeComplexity() + symRHS->computeComplexity()) <  MaxComp)
     return makeNonLoc(symLHS, Op, symRHS, ResultTy);
 
   if (symLHS && symLHS->computeComplexity() < MaxComp)
     if (Optional<nonloc::ConcreteInt> rInt = RHS.getAs<nonloc::ConcreteInt>())
       return makeNonLoc(symLHS, Op, rInt->getValue(), ResultTy);

lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

static Optional<NonLoc> tryRearrange(ProgramStateRef State,
   QualType SingleTy;
 
   auto &Opts =
     StateMgr.getOwningEngine()->getAnalysisManager().getAnalyzerOptions();
 
   // FIXME: After putting complexity threshold to the symbols we can always
   //        rearrange additive operations but rearrange comparisons only if
   //        option is set.
-  if(!Opts.shouldAggressivelySimplifyBinaryOperation())
+  if(!Opts.ShouldAggressivelySimplifyBinaryOperation)
     return None;
 
   SymbolRef LSym = Lhs.getAsSymbol();
   if (!LSym)
     return None;
 
   if (BinaryOperator::isComparisonOp(Op)) {
     SingleTy = LSym->getType();

lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

public:
 
   AnalysisConsumer(CompilerInstance &CI, const std::string &outdir,
                    AnalyzerOptionsRef opts, 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) {
     DigestAnalyzerOptions();
-    if (Opts->PrintStats || Opts->shouldSerializeStats()) {
+    if (Opts->PrintStats || Opts->ShouldSerializeStats) {
       AnalyzerTimers = llvm::make_unique<llvm::TimerGroup>(
           "analyzer", "Analyzer timers");
       TUTotalTimer = llvm::make_unique<llvm::Timer>(
           "time", "Analyzer total time", *AnalyzerTimers);
       llvm::EnableStatistics(/* PrintOnExit= */ false);
     }
   }
 
void AnalysisConsumer::RunPathSensitiveChecks(Decl *D,
   // See if the LiveVariables analysis scales.
   if (!Mgr->getAnalysisDeclContext(D)->getAnalysis<RelaxedLiveVariables>())
     return;
 
   ExprEngine Eng(CTU, *Mgr, VisitedCallees, &FunctionSummaries, IMode);
 
   // Execute the worklist algorithm.
   Eng.ExecuteWorkList(Mgr->getAnalysisDeclContextManager().getStackFrame(D),
-                      Mgr->options.getMaxNodesPerTopLevelFunction());
+                      Mgr->options.MaxNodesPerTopLevelFunction);
 
   if (!Mgr->options.DumpExplodedGraphTo.empty())
     Eng.DumpGraph(Mgr->options.TrimGraph, Mgr->options.DumpExplodedGraphTo);
 
   // Visualize the exploded graph.
   if (Mgr->options.visualizeExplodedGraphWithGraphViz)
     Eng.ViewGraph(Mgr->options.TrimGraph);
 

lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
   // about file name index? Mangled names may not be suitable for that either.
   if (Bodies.count(D->getName()) != 0)
     return;
 
   SourceManager &SM = CI.getSourceManager();
   FileID mainFileID = SM.getMainFileID();
 
   AnalyzerOptionsRef analyzerOpts = CI.getAnalyzerOpts();
-  llvm::StringRef modelPath = analyzerOpts->getModelPath();
+  llvm::StringRef modelPath = analyzerOpts->ModelPath;
 
   llvm::SmallString<128> fileName;
 
   if (!modelPath.empty())
     fileName =
         llvm::StringRef(modelPath.str() + "/" + D->getName().str() + ".model");
   else
     fileName = llvm::StringRef(D->getName().str() + ".model");

test/Analysis/analyzer-config.c

 // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 %s -o /dev/null -analyzer-checker=core,osx.cocoa,debug.ConfigDumper -analyzer-max-loop 34 > %t 2>&1
 // RUN: FileCheck --input-file=%t %s --match-full-lines
 
-void bar() {}
-void foo() {
-  // Call bar 33 times so max-times-inline-large is met and
-  // min-blocks-for-inline-large is checked
-  for (int i = 0; i < 34; ++i) {
-    bar();
-  }
-}
-
 // CHECK: [config]
+// CHECK-NEXT: aggressive-binary-operation-simplification = false
+// CHECK-NEXT: avoid-suppressing-null-argument-paths = false
+// CHECK-NEXT: c++-allocator-inlining = true
+// CHECK-NEXT: c++-container-inlining = false
+// CHECK-NEXT: c++-inlining = destructors
+// CHECK-NEXT: c++-shared_ptr-inlining = false
+// CHECK-NEXT: c++-stdlib-inlining = true
+// CHECK-NEXT: c++-temp-dtor-inlining = true
+// CHECK-NEXT: c++-template-inlining = true
 // CHECK-NEXT: cfg-conditional-static-initializers = true
 // CHECK-NEXT: cfg-implicit-dtors = true
 // CHECK-NEXT: cfg-lifetime = false
 // CHECK-NEXT: cfg-loopexit = false
 // CHECK-NEXT: cfg-rich-constructors = true
 // CHECK-NEXT: cfg-scopes = false
 // CHECK-NEXT: cfg-temporary-dtors = true
+// CHECK-NEXT: crosscheck-with-z3 = false
+// CHECK-NEXT: ctu-dir = ""
+// CHECK-NEXT: ctu-index-name = externalFnMap.txt
 // CHECK-NEXT: eagerly-assume = true
 // CHECK-NEXT: elide-constructors = true
+// CHECK-NEXT: expand-macros = false
+// CHECK-NEXT: experimental-enable-naive-ctu-analysis = false
 // CHECK-NEXT: exploration_strategy = unexplored_first_queue
 // CHECK-NEXT: faux-bodies = true
 // CHECK-NEXT: graph-trim-interval = 1000
 // CHECK-NEXT: inline-lambdas = true
 // CHECK-NEXT: ipa = dynamic-bifurcate
 // CHECK-NEXT: ipa-always-inline-size = 3
 // CHECK-NEXT: max-inlinable-size = 100
 // CHECK-NEXT: max-nodes = 225000
+// CHECK-NEXT: max-symbol-complexity = 35
 // CHECK-NEXT: max-times-inline-large = 32
 // CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14
 // CHECK-NEXT: mode = deep
+// CHECK-NEXT: model-path = ""
+// CHECK-NEXT: notes-as-events = false
+// CHECK-NEXT: objc-inlining = true
+// CHECK-NEXT: prune-paths = true
 // CHECK-NEXT: region-store-small-struct-limit = 2
+// CHECK-NEXT: report-in-main-source-file = false
 // CHECK-NEXT: serialize-stats = false
+// CHECK-NEXT: stable-report-filename = false
+// CHECK-NEXT: suppress-c++-stdlib = true
+// CHECK-NEXT: suppress-inlined-defensive-checks = true
+// CHECK-NEXT: suppress-null-return-paths = true
 // CHECK-NEXT: unroll-loops = false
 // CHECK-NEXT: widen-loops = false
 // CHECK-NEXT: [stats]
-// CHECK-NEXT: num-entries = 24
+// CHECK-NEXT: num-entries = 48

test/Analysis/analyzer-config.cpp

 // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 %s -o /dev/null -analyzer-checker=core,osx.cocoa,debug.ConfigDumper -analyzer-max-loop 34 > %t 2>&1
 // RUN: FileCheck --input-file=%t %s --match-full-lines
 
-void bar() {}
-void foo() {
-  // Call bar 33 times so max-times-inline-large is met and
-  // min-blocks-for-inline-large is checked
-  for (int i = 0; i < 34; ++i) {
-    bar();
-  }
-}
-
-class Foo {
-public:
-  ~Foo() {}
-  void baz() { Foo(); }
-  void bar() { const Foo &f = Foo(); }
-  void foo() { bar(); }
-};
-
 // CHECK: [config]
+// CHECK-NEXT: aggressive-binary-operation-simplification = false
+// CHECK-NEXT: avoid-suppressing-null-argument-paths = false
+// CHECK-NEXT: c++-allocator-inlining = true
 // CHECK-NEXT: c++-container-inlining = false
 // CHECK-NEXT: c++-inlining = destructors
 // CHECK-NEXT: c++-shared_ptr-inlining = false
 // CHECK-NEXT: c++-stdlib-inlining = true
 // CHECK-NEXT: c++-temp-dtor-inlining = true
 // CHECK-NEXT: c++-template-inlining = true
 // CHECK-NEXT: cfg-conditional-static-initializers = true
 // CHECK-NEXT: cfg-implicit-dtors = true
 // CHECK-NEXT: cfg-lifetime = false
 // CHECK-NEXT: cfg-loopexit = false
 // CHECK-NEXT: cfg-rich-constructors = true
 // CHECK-NEXT: cfg-scopes = false
 // CHECK-NEXT: cfg-temporary-dtors = true
+// CHECK-NEXT: crosscheck-with-z3 = false
+// CHECK-NEXT: ctu-dir = ""
+// CHECK-NEXT: ctu-index-name = externalFnMap.txt
 // CHECK-NEXT: eagerly-assume = true
 // CHECK-NEXT: elide-constructors = true
+// CHECK-NEXT:expand-macros = false
 // CHECK-NEXT: experimental-enable-naive-ctu-analysis = false
 // CHECK-NEXT: exploration_strategy = unexplored_first_queue
 // CHECK-NEXT: faux-bodies = true
 // CHECK-NEXT: graph-trim-interval = 1000
 // CHECK-NEXT: inline-lambdas = true
 // CHECK-NEXT: ipa = dynamic-bifurcate
 // CHECK-NEXT: ipa-always-inline-size = 3
 // CHECK-NEXT: max-inlinable-size = 100
 // CHECK-NEXT: max-nodes = 225000
+// CHECK-NEXT: max-symbol-complexity = 35
 // CHECK-NEXT: max-times-inline-large = 32
 // CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14
 // CHECK-NEXT: mode = deep
+// CHECK-NEXT: model-path = ""
+// CHECK-NEXT: notes-as-events = false
+// CHECK-NEXT: objc-inlining = true
+// CHECK-NEXT: prune-paths = true
 // CHECK-NEXT: region-store-small-struct-limit = 2
+// CHECK-NEXT: report-in-main-source-file = false
 // CHECK-NEXT: serialize-stats = false
+// CHECK-NEXT: stable-report-filename = false
+// CHECK-NEXT: suppress-c++-stdlib = true
+// CHECK-NEXT: suppress-inlined-defensive-checks = true
+// CHECK-NEXT: suppress-null-return-paths = true
 // CHECK-NEXT: unroll-loops = false
 // CHECK-NEXT: widen-loops = false
 // CHECK-NEXT: [stats]
-// CHECK-NEXT: num-entries = 31
+// CHECK-NEXT: num-entries = 48