[analyzer] Create infrastructure for organizing and declaring analyzer configs.

[teemperor]

Summary

This patch is a first step towards restructuring the way we handle configs (i.e. the values we pass for example to -analyzer-config).

At the moment all configs are only implicitly defined by checking for them from some checker in the SA, which makes many aspects regarding the management of those options much harder than it should be. For example is it currently not really possible to recognize typos in the config keys that the user provided. We do some basic checking if the targeted checker is registered, but we don't do any checking if the given config is actually something that exists. This means that any typos in the -analyzer-config that aren't affecting the checker won't be reported or noticed by the SA. It also means that making a list of what configurations are available isn't possible at the moment without grepping the source code.

With this patch all configurations of the SA are moved to the Checkers.td and are emitted to the Checkers.inc. We also add support for adding/checking options to the CheckerRegistry and are using this to verify if the provided configuration values actually exist.

[teemperor]

I'm open to suggestions how we should handle user-provided checkers that maybe come with their own configs. Should we add that if we have a custom checker in the registry, that we disable this check to keep backwards compability? Or do we demand users to register their own configs in the registry?

[teemperor]

• Remove some unneeded includes

[xazax.hun]

I like the directions of this patch.
In general, I am in favor of explicitly registering the options from user defined checkers.
But changing a config option will now break the command line compatibility, so I wonder how do we want to handle this:

• Have a list of no-op configs that we accept but warn that it has been replaced/removed?
• Just do not care and break compatibility?
• Something else?

I have a wishlist for this feature but I am perfectly fine to only address those in follow-up patches:

• Ability to set descriptions and maybe default values in the Checkers.td
• Command line argument to dump the list of options with descriptions (and defaults)

[teemperor]

In D36067#825867, @xazax.hun wrote:

I like the directions of this patch.
In general, I am in favor of explicitly registering the options from user defined checkers.
But changing a config option will now break the command line compatibility, so I wonder how do we want to handle this:

• Have a list of no-op configs that we accept but warn that it has been replaced/removed?
• Just do not care and break compatibility?
• Something else?

Don't have a preference here, but adding a forwarding config that also emits a warning should be easy to do.

I have a wishlist for this feature but I am perfectly fine to only address those in follow-up patches:

• Ability to set descriptions and maybe default values in the Checkers.td
• Command line argument to dump the list of options with descriptions (and defaults)

Yes, I would prefer having this in follow up patches. I tried to keep this as a minimal starting example because this currently blocks @yamaguchi 's GSoC project for bash completion. There we want to complete the values for -analyzer-config and we currently don't have a good way to get a complete list of available configs from the driver :).

[zaks.anna]

I tried to keep this as a minimal starting example because this currently blocks @yamaguchi 's GSoC project for bash completion. There we want to complete the values for -analyzer-config and we currently don't have a good way to get a complete list of available configs from the driver :).

It is not clear that we want to make the analyzer options user visible. These often used for staging purposes, where we develop a feature or a set of heuristics behind a flag. We do not support changing a lot of these options.

[dcoughlin]

I just want to second that we really don't want to treat the analyzer-config options as user visible. These are useful as staging flags for analyzer development/testing and occasionally as customization points for IDEs/build systems. But they do not expose a coherent (or even intelligible) model to the end user. In particular, this means that we should never, ever ask (or recommend) that the end user set these from the command line. They are also not API -- we make no promises of backward compatibility.

We also do sometimes use analyzer config flags as an escape hatch that lets us pass a flag to both a new clang (which understands the flag) and an old flag (which doesn't). It would be a shame if we lost that escape hatch.

[teemperor]

I see, thanks for the information! If we don't need to support this in the shell-completion and we shouldn't report invalid arguments, then it seems this review is stuck here. I'll abandon as I don't see any other use case for this code.

(Also, sorry for the late response).

include/clang/Basic/DiagnosticFrontendKinds.td

def warn_unknown_diag_option : Warning<
     "unknown %select{warning|remark}0 option '%1'%select{|; did you mean '%3'?}2">,
     InGroup<UnknownWarningOption>;
 def warn_unknown_warning_specifier : Warning<
     "unknown %0 warning specifier: '%1'">,
     InGroup<UnknownWarningOption>;
 
 def err_unknown_analyzer_checker : Error<
     "no analyzer checkers are associated with '%0'">;
+def err_unknown_analyzer_config : Error<
+    "no analyzer configs are associated with '%0'">;
 def note_suggest_disabling_all_checkers : Note<
     "use -analyzer-disable-all-checks to disable all static analyzer checkers">;
 
 def warn_incompatible_analyzer_plugin_api : Warning<
     "checker plugin '%0' is not compatible with this version of the analyzer">,
     InGroup<DiagGroup<"analyzer-incompatible-plugin"> >;
 def note_incompatible_analyzer_plugin_api : Note<
     "current API version is '%0', but plugin was compiled with version '%1'">;

include/clang/StaticAnalyzer/Checkers/CheckerBase.td

 //
 //===----------------------------------------------------------------------===//
 
 class CheckerGroup<string name> {
   string GroupName = name;
 }
 class InGroup<CheckerGroup G> { CheckerGroup Group = G; }
 
+class Config<string name> {
+  string       ConfigName = name;
+}
+
+class GlobalConfig<string name> : Config<name> {}
+
 class Package<string name> {
   string       PackageName = name;
   bit          Hidden = 0;
   Package ParentPackage;
   CheckerGroup Group;
+  list<Config> Configs = [];
 }
 class InPackage<Package P> { Package ParentPackage = P; }
 
 // All checkers are an indirect subclass of this.
 class Checker<string name = ""> {
   string      CheckerName = name;
   string      DescFile;
   string      HelpText;
   bit         Hidden = 0;
   Package ParentPackage;
   CheckerGroup Group;
+  list<Config> Configs = [];
 }
 
 class DescFile<string filename> { string DescFile = filename; }
 class HelpText<string text> { string HelpText = text; }
 class Hidden { bit Hidden = 1; }
+class HasConfigs<list<Config> C> { list<Config> Configs = C; }

include/clang/StaticAnalyzer/Checkers/Checkers.td

 //===--- Checkers.td - Static Analyzer Checkers -===-----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 include "clang/StaticAnalyzer/Checkers/CheckerBase.td"
 
 //===----------------------------------------------------------------------===//
 // Packages.
 //===----------------------------------------------------------------------===//
 
+// Package configs
+
+def OptimisticConfig : Config<"Optimistic">;
+def NoDiagnoseCallsToSystemHeadersConfig : Config<"NoDiagnoseCallsToSystemHeaders">;
+
 // The Alpha package is for checkers that have too many false positives to be
 // turned on by default. The hierarchy under Alpha should be organized in the
 // hierarchy checkers would have had if they were truly at the top level.
 // (For example, a Cocoa-specific checker that is alpha should be in
 // alpha.osx.cocoa).
 def Alpha : Package<"alpha">;
 
 def Core : Package<"core">;

 // default. Such checkers belong in the alpha package.
 def OptIn : Package<"optin">;
 
 // In the Portability package reside checkers for finding code that relies on
 // implementation-defined behavior. Such checks are wanted for cross-platform
 // development, but unwanted for developers who target only a single platform.
 def PortabilityOptIn : Package<"portability">, InPackage<OptIn>;
 
-def Nullability : Package<"nullability">;
+def Nullability : Package<"nullability">,
+                  HasConfigs<[NoDiagnoseCallsToSystemHeadersConfig]>;
 
 def Cplusplus : Package<"cplusplus">;
 def CplusplusAlpha : Package<"cplusplus">, InPackage<Alpha>, Hidden;
 def CplusplusOptIn : Package<"cplusplus">, InPackage<OptIn>;
 
 def Valist : Package<"valist">;
 
 def DeadCode : Package<"deadcode">;
 def DeadCodeAlpha : Package<"deadcode">, InPackage<Alpha>, Hidden;
 
 def Performance : Package<"performance">, InPackage<OptIn>;
 
 def Security : Package <"security">;
 def InsecureAPI : Package<"insecureAPI">, InPackage<Security>;
 def SecurityAlpha : Package<"security">, InPackage<Alpha>, Hidden;
 def Taint : Package<"taint">, InPackage<SecurityAlpha>, Hidden;
 
-def Unix : Package<"unix">;
+def Unix : Package<"unix">, HasConfigs<[OptimisticConfig]>;
 def UnixAlpha : Package<"unix">, InPackage<Alpha>, Hidden;
 def CString : Package<"cstring">, InPackage<Unix>, Hidden;
 def CStringAlpha : Package<"cstring">, InPackage<UnixAlpha>, Hidden;
 
 def OSX : Package<"osx">;
 def OSXAlpha : Package<"osx">, InPackage<Alpha>, Hidden;
 def OSXOptIn : Package<"osx">, InPackage<OptIn>;
 

 def APIModeling : Package<"apiModeling">, Hidden;
 def GoogleAPIModeling : Package<"google">, InPackage<APIModeling>;
 
 def Debug : Package<"debug">;
 
 def CloneDetectionAlpha : Package<"clone">, InPackage<Alpha>, Hidden;
 
 //===----------------------------------------------------------------------===//
+// Global configs.
+//===----------------------------------------------------------------------===//
+
+def AllConfig                              : GlobalConfig<"*">;
+def AvoidSuppressingNullArgumentPaths      : GlobalConfig<"avoid-suppressing-null-argument-paths">;
+def CxxAllocatorInliningConfig             : GlobalConfig<"c++-allocator-inlining">;
+def CxxcontainerInliningConfig             : GlobalConfig<"c++-container-inlining">;
+def CfgConditionalStaticInitializersConfig : GlobalConfig<"cfg-conditional-static-initializers">;
+def CfgImplicitDtorsConfig                 : GlobalConfig<"cfg-implicit-dtors">;
+def CfgLifetimeConfig                      : GlobalConfig<"cfg-lifetime">;
+def CfgTemporaryDtorsConfig                : GlobalConfig<"cfg-temporary-dtors">;
+def CxxinliningConfig                      : GlobalConfig<"c++-inlining">;
+def CxxstdlibInliningConfig                : GlobalConfig<"c++-stdlib-inlining">;
+def CxxtemplateInliningConfig              : GlobalConfig<"c++-template-inlining">;
+def FauxBodiesConfig                       : GlobalConfig<"faux-bodies">;
+def GraphTrimIntervalConfig                : GlobalConfig<"graph-trim-interval">;
+def InlineLambdasConfig                    : GlobalConfig<"inline-lambdas">;
+def IpaConfig                              : GlobalConfig<"ipa">;
+def IpaAlwaysInlineSizeConfig              : GlobalConfig<"ipa-always-inline-size">;
+def LeakDiagnosticsReferenceAllocConfig    : GlobalConfig<"leak-diagnostics-reference-allocation">;
+def MaxNodesConfig                         : GlobalConfig<"max-nodes">;
+def MaxInlinableSize                       : GlobalConfig<"max-inlinable-size">;
+def MaxTimesInlineLarge                    : GlobalConfig<"max-times-inline-large">;
+def ModeConfig                             : GlobalConfig<"mode">;
+def ModelPathConfig                        : GlobalConfig<"model-path">;
+def NotesSsEventsConfig                    : GlobalConfig<"notes-as-events">;
+def ObjcInliningConfig                     : GlobalConfig<"objc-inlining">;
+def PathDiagnosticsAlternateConfig         : GlobalConfig<"path-diagnostics-alternate">;
+def PrunePathsConfig                       : GlobalConfig<"prune-paths">;
+def RegionStoreSmallStructLimitConfig      : GlobalConfig<"region-store-small-struct-limit">;
+def ReportInMainSourceFileConfig           : GlobalConfig<"report-in-main-source-file">;
+def SuppressCxxStdlibConfig                : GlobalConfig<"suppress-c++-stdlib">;
+def SuppressInlinedDefensiveChecksConfig   : GlobalConfig<"suppress-inlined-defensive-checks">;
+def SuppressNullReturnPathsConfig          : GlobalConfig<"suppress-null-return-paths">;
+def UnrollLoopsConfig                      : GlobalConfig<"unroll-loops">;
+def WidenLoopsConfig                       : GlobalConfig<"widen-loops">;
+
+//===----------------------------------------------------------------------===//
 // Core Checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Core in {
 
 def DereferenceChecker : Checker<"NullDereference">,
   HelpText<"Check for dereferences of null pointers">,
   DescFile<"DereferenceChecker.cpp">;
def NewDeleteLeaksChecker : Checker<"NewDeleteLeaks">,
   DescFile<"MallocChecker.cpp">;
 
 def CXXSelfAssignmentChecker : Checker<"SelfAssignment">,
   HelpText<"Checks C++ copy and move assignment operators for self assignment">,
   DescFile<"CXXSelfAssignmentChecker.cpp">;
 
 } // end: "cplusplus"
 
+def Interprocedural : Config<"Interprocedural">;
+def PureOnly : Config<"PureOnly">;
+
 let ParentPackage = CplusplusOptIn in {
 
 def VirtualCallChecker : Checker<"VirtualCall">,
   HelpText<"Check virtual function calls during construction or destruction">,
-  DescFile<"VirtualCallChecker.cpp">;
+  DescFile<"VirtualCallChecker.cpp">,
+  HasConfigs<[Interprocedural, PureOnly]>;
 
 } // end: "optin.cplusplus"
 
 let ParentPackage = CplusplusAlpha in {
 
 def IteratorRangeChecker : Checker<"IteratorRange">,
   HelpText<"Check for iterators used outside their valid ranges">,
   DescFile<"IteratorChecker.cpp">;
def UnreachableCodeChecker : Checker<"UnreachableCode">,
   DescFile<"UnreachableCodeChecker.cpp">;
 
 } // end "alpha.deadcode"
 
 //===----------------------------------------------------------------------===//
 // Performance checkers.
 //===----------------------------------------------------------------------===//
 
+def AllowedPad : Config<"AllowedPad">;
+
 let ParentPackage = Performance in {
 
 def PaddingChecker : Checker<"Padding">,
   HelpText<"Check for excessively padded structs.">,
-  DescFile<"PaddingChecker.cpp">;
+  DescFile<"PaddingChecker.cpp">,
+  HasConfigs<[AllowedPad]>;
 
 } // end: "padding"
 
 //===----------------------------------------------------------------------===//
 // Security checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = InsecureAPI in {
def CStringNotNullTerm : Checker<"NotNullTerminated">,
   HelpText<"Check for arguments which are not null-terminating strings">,
   DescFile<"CStringChecker.cpp">;
 }
 
 //===----------------------------------------------------------------------===//
 // Mac OS X, Cocoa, and Core Foundation checkers.
 //===----------------------------------------------------------------------===//
 
+def Pedantic : Config<"Pedantic">;
+
 let ParentPackage = OSX in {
 
 def NumberObjectConversionChecker : Checker<"NumberObjectConversion">,
   HelpText<"Check for erroneous conversions of objects representing numbers into numbers">,
-  DescFile<"NumberObjectConversionChecker.cpp">;
+  DescFile<"NumberObjectConversionChecker.cpp">,
+  HasConfigs<[Pedantic]>;
 
 def MacOSXAPIChecker : Checker<"API">,
   HelpText<"Check for proper uses of various Apple APIs">,
   DescFile<"MacOSXAPIChecker.cpp">;
 
 def MacOSKeychainAPIChecker : Checker<"SecKeychainAPI">,
   HelpText<"Check for proper uses of Secure Keychain APIs">,
   DescFile<"MacOSKeychainAPIChecker.cpp">;
def ObjCContainersASTChecker : Checker<"PointerSizedValues">,
   DescFile<"ObjCContainersASTChecker.cpp">;
 
 def ObjCContainersChecker : Checker<"OutOfBounds">,
   HelpText<"Checks for index out-of-bounds when using 'CFArray' API">,
   DescFile<"ObjCContainersChecker.cpp">;
 
 }
 
+// FIXME: Only used by NonLocalizedStringChecker, should be attached there?
+def AggressiveReportConfig : GlobalConfig<"AggressiveReport">;
+
 let ParentPackage = LocalizabilityOptIn in {
 def NonLocalizedStringChecker : Checker<"NonLocalizedStringChecker">,
   HelpText<"Warns about uses of non-localized NSStrings passed to UI methods expecting localized NSStrings">,
   DescFile<"LocalizationChecker.cpp">;
 
 def EmptyLocalizationContextChecker : Checker<"EmptyLocalizationContextChecker">,
   HelpText<"Check that NSLocalizedString macros include a comment for context">,
   DescFile<"LocalizationChecker.cpp">;
def GTestChecker : Checker<"GTest">,
   InPackage<GoogleAPIModeling>,
   HelpText<"Model gtest assertion APIs">,
   DescFile<"GTestChecker.cpp">;
 
 //===----------------------------------------------------------------------===//
 // Debugging checkers (for analyzer development).
 //===----------------------------------------------------------------------===//
 
+def Bind             : Config<"Bind">;
+def PostStmtCastExpr : Config<"PostStmtCastExpr">;
+def PreStmtCastExpr  : Config<"PreStmtCastExpr">;
+def RegionChanges    : Config<"RegionChanges">;
+
 let ParentPackage = Debug in {
 
 def AnalysisOrderChecker : Checker<"AnalysisOrder">,
   HelpText<"Print callbacks that are called during analysis in order">,
-  DescFile<"AnalysisOrder.cpp">;
+  DescFile<"AnalysisOrder.cpp">,
+  HasConfigs<[Bind,
+              PostStmtCastExpr,
+              PreStmtCastExpr,
+              RegionChanges]>;
 
 def DominatorsTreeDumper : Checker<"DumpDominators">,
   HelpText<"Print the dominance tree for a given CFG">,
   DescFile<"DebugCheckers.cpp">;
 
 def LiveVariablesDumper : Checker<"DumpLiveVars">,
   HelpText<"Print results of live variable analysis">,
   DescFile<"DebugCheckers.cpp">;

 
 } // end "debug"
 
 
 //===----------------------------------------------------------------------===//
 // Clone Detection
 //===----------------------------------------------------------------------===//
 
+def IgnoredFilesPattern : Config<"IgnoredFilesPattern">;
+def MinimumCloneComplexity : Config<"MinimumCloneComplexity">;
+def ReportNormalClones : Config<"ReportNormalClones">;
+def ReportSuspiciousClones : Config<"ReportSuspiciousClones">;
+
 let ParentPackage = CloneDetectionAlpha in {
 
 def CloneChecker : Checker<"CloneChecker">,
   HelpText<"Reports similar pieces of code.">,
-  DescFile<"CloneChecker.cpp">;
+  DescFile<"CloneChecker.cpp">,
+  HasConfigs<[IgnoredFilesPattern,
+              MinimumCloneComplexity,
+              ReportNormalClones,
+              ReportSuspiciousClones]>;
 
 } // end "clone"
 
 //===----------------------------------------------------------------------===//
 // Portability checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = PortabilityOptIn in {
 
 def UnixAPIPortabilityChecker : Checker<"UnixAPI">,
   HelpText<"Finds implementation-defined behavior in UNIX/Posix functions">,
   DescFile<"UnixAPIChecker.cpp">;
 
 } // end optin.portability

include/clang/StaticAnalyzer/Core/CheckerRegistry.h

struct CheckerInfo {
     InitializationFunction Initialize;
     StringRef FullName;
     StringRef Desc;
 
     CheckerInfo(InitializationFunction fn, StringRef name, StringRef desc)
     : Initialize(fn), FullName(name), Desc(desc) {}
   };
 
+  /// A config value.
+  struct Config {
+    StringRef FullName;
+    // TODO: Supports descriptions, default value etc. here.
+  };
+
+  /// All configs known to this registry mapped by their full name.
+  llvm::StringMap<Config> Configs;
+
   typedef std::vector<CheckerInfo> CheckerInfoList;
 
 private:
   template <typename T>
   static void initializeManager(CheckerManager &mgr) {
     mgr.registerChecker<T>();
   }
 
 public:
   /// Adds a checker to the registry. Use this non-templated overload when your
   /// checker requires custom initialization.
   void addChecker(InitializationFunction fn, StringRef fullName,
                   StringRef desc);
 
   /// Adds a checker to the registry. Use this templated overload when your
   /// checker does not require any custom initialization.
   template <class T>
   void addChecker(StringRef fullName, StringRef desc) {
     // Avoid MSVC's Compiler Error C2276:
     // http://msdn.microsoft.com/en-us/library/850cstw1(v=VS.80).aspx
     addChecker(&CheckerRegistry::initializeManager<T>, fullName, desc);
   }
 
+  /// Adds a config to the registry that the user can use to modify the behavior
+  /// of certain checkers.
+  /// \param fullName The full name of the new config in the same format as the
+  ///                 '-analyzer-config' flag of clang expects. For example
+  ///                 'core.pkg:Setting' or 'core.alpha.TestChecker:TestConfig'.
+  void addConfig(StringRef fullName);
+
+  /// Checks if the given full name of the config is known to this registry.
+  ///
+  /// Also checks all parent packages for a config with the given name. The
+  /// config 'TestConfig' in 'core.alpha.TestChecker:TestConfig' would be
+  /// searched in 'core', 'core.alpha' and 'core.alpha.TestChecker'.
+  ///
+  /// \param fullName The full name of the new config in the same format as the
+  ///                 '-analyzer-config' flag of clang expects. For example
+  ///                 'core.pkg:Setting' or 'core.alpha.TestChecker:TestConfig'.
+  bool hasConfig(StringRef fullName) const;
+
   /// Initializes a CheckerManager by calling the initialization functions for
   /// all checkers specified by the given CheckerOptInfo list. The order of this
   /// list is significant; later options can be used to reverse earlier ones.
   /// This can be used to exclude certain checkers in an included package.
   void initializeManager(CheckerManager &mgr,
                          SmallVectorImpl<CheckerOptInfo> &opts) const;
 
-  /// Check if every option corresponds to a specific checker or package.
+  /// Check if every option corresponds to a specific checker or package and was
+  /// previously added to this registry.
   void validateCheckerOptions(const AnalyzerOptions &opts,
                               DiagnosticsEngine &diags) const;
 
   /// Prints the name and description of all checkers in this registry.
   /// This output is not intended to be machine-parseable.
   void printHelp(raw_ostream &out, size_t maxNameChars = 30) const;
   void printList(raw_ostream &out,
                  SmallVectorImpl<CheckerOptInfo> &opts) const;

lib/StaticAnalyzer/Checkers/ClangCheckers.cpp

 using namespace ento;
 
 void ento::registerBuiltinCheckers(CheckerRegistry &registry) {
 #define GET_CHECKERS
 #define CHECKER(FULLNAME,CLASS,DESCFILE,HELPTEXT,GROUPINDEX,HIDDEN)    \
   registry.addChecker(register##CLASS, FULLNAME, HELPTEXT);
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef GET_CHECKERS
+
+#define GET_GLOBAL_CONFIGS
+#define GLOBAL_CONFIG(NAME) registry.addConfig(NAME);
+#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
+#undef GET_GLOBAL_CONFIGS
+
+#define GET_CHECKER_CONFIGS
+#define CHECKER_CONFIG(CHECKER, NAME) registry.addConfig(CHECKER ":" NAME);
+#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
+#undef GET_CHECKER_CONFIGS
+
+#define GET_PACKAGE_CONFIGS
+#define PACKAGE_CONFIG(PACKAGE, NAME) registry.addConfig(PACKAGE ":" NAME);
+#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
+#undef GET_PACKAGE_CONFIGS
 }

lib/StaticAnalyzer/Core/CheckerRegistry.cpp

 //===--- CheckerRegistry.cpp - Maintains all available checkers -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/CheckerRegistry.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
-#include "clang/StaticAnalyzer/Core/CheckerOptInfo.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
+#include "clang/StaticAnalyzer/Core/CheckerOptInfo.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;
 
 static const char PackageSeparator = '.';
 typedef llvm::SetVector<const CheckerRegistry::CheckerInfo *> CheckerInfoSet;
 
void CheckerRegistry::addChecker(InitializationFunction fn, StringRef name,
   StringRef packageName, leafName;
   std::tie(packageName, leafName) = name.rsplit(PackageSeparator);
   while (!leafName.empty()) {
     Packages[packageName] += 1;
     std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
   }
 }
 
-void CheckerRegistry::initializeManager(CheckerManager &checkerMgr,
-                                  SmallVectorImpl<CheckerOptInfo> &opts) const {
+void CheckerRegistry::addConfig(llvm::StringRef fullName) {
+  Configs[fullName] = {fullName};
+}
+
+bool CheckerRegistry::hasConfig(llvm::StringRef fullName) const {
+  // Let's first see if we can directly find the config value in our map, this
+  // handles all global configs and all configs that are directly specified
+  // to the packages/checkers they belong to.
+  // Examples are 'core.MemoryChecker:MemoryVal' if the MemoryChecker is
+  // declared to have the MemoryVal config.
+  if (Configs.count(fullName) == 1)
+    return true;
+
+  // Direct lookup failed, but we still have to check all parent packages below.
+
+  size_t pos = fullName.find(':');
+  if (pos == StringRef::npos || pos == fullName.size() - 1) {
+    // At this point we either have a marformed config key (like 'foo:') or
+    // we would have been handled in the lookup above, so we can fail now.
+    return false;
+  }
+  // Split the key into checkerName (or package name) and the configName.
+  StringRef checkerName = fullName.substr(0, pos);
+  StringRef configName = fullName.substr(pos + 1);
+
+  SmallVector<StringRef, 8> parts;
+  checkerName.split(parts, '.');
+  // Iterate over all parent packages and check if they have such a config.
+  for (size_t i = 1; i <= parts.size(); ++i) {
+    std::string newConfig = llvm::join(parts.begin(), parts.begin() + i, ".");
+    if (Configs.count(newConfig + ":" + configName.str()) == 1)
+      return true;
+  }
+  // No parent package had such a config, so we can assume the option doesn't
+  // exist in this registry.
+  return false;
+}
+
+void CheckerRegistry::initializeManager(
+    CheckerManager &checkerMgr, SmallVectorImpl<CheckerOptInfo> &opts) const {
   // Sort checkers for efficient collection.
   std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
 
   // Collect checkers enabled by the options.
   CheckerInfoSet enabledCheckers;
   for (SmallVectorImpl<CheckerOptInfo>::iterator
          i = opts.begin(), e = opts.end(); i != e; ++i) {
     collectCheckers(Checkers, Packages, *i, enabledCheckers);
   }
 
   // Initialize the CheckerManager with all enabled checkers.
   for (CheckerInfoSet::iterator
          i = enabledCheckers.begin(), e = enabledCheckers.end(); i != e; ++i) {
     checkerMgr.setCurrentCheckName(CheckName((*i)->FullName));
     (*i)->Initialize(checkerMgr);
   }
 }
 
 void CheckerRegistry::validateCheckerOptions(const AnalyzerOptions &opts,
                                              DiagnosticsEngine &diags) const {
   for (auto &config : opts.Config) {
     size_t pos = config.getKey().find(':');
-    if (pos == StringRef::npos)
+    if (pos == StringRef::npos) {
+      // It's a global config, so no checker configuration required, but we
+      // still need to verify if the config is valid.
+      if (!hasConfig(config.getKey()))
+        diags.Report(diag::err_unknown_analyzer_config) << config.getKey();
       continue;
+    }
 
     bool hasChecker = false;
     StringRef checkerName = config.getKey().substr(0, pos);
     for (auto &checker : Checkers) {
       if (checker.FullName.startswith(checkerName) &&
           (checker.FullName.size() == pos || checker.FullName[pos] == '.')) {
         hasChecker = true;
         break;
       }
     }
-    if (!hasChecker) {
+    if (hasChecker) {
+      // We have such a checker, but we still need to verify if the checker
+      // actually has the given config value.
+      if (!hasConfig(config.getKey()))
+        diags.Report(diag::err_unknown_analyzer_config) << config.getKey();
+    } else {
       diags.Report(diag::err_unknown_analyzer_checker) << checkerName;
     }
   }
 }
 
 void CheckerRegistry::printHelp(raw_ostream &out,
                                 size_t maxNameChars) const {
   // FIXME: Alphabetical sort puts 'experimental' in the middle.

test/Analysis/analyzer-checker-config.c

-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.mallo:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni.:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config ..:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unrelated:Optimistic=true 2>&1 | FileCheck %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.mallo:Optimistic=true 2>&1 | FileCheck --check-prefix=NO_ANALYZER %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni:Optimistic=true 2>&1 | FileCheck --check-prefix=NO_ANALYZER %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni.:Optimistic=true 2>&1 | FileCheck --check-prefix=NO_ANALYZER %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config ..:Optimistic=true 2>&1 | FileCheck --check-prefix=NO_ANALYZER %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.:Optimistic=true 2>&1 | FileCheck --check-prefix=NO_ANALYZER %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unrelated:Optimistic=true 2>&1 | FileCheck --check-prefix=NO_ANALYZER %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.Malloc:Optimistic=true
 
+// NO_ANALYZER: error: no analyzer checkers are associated with
+
+// valid global config:
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config ipa=dynamic-bifurcate
+// invalid global config:
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config ipaFunnyTypo=true 2>&1 | FileCheck --check-prefix=NO_CONFIG %s
+
+// valid package config:
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config nullability:NoDiagnoseCallsToSystemHeaders=true
+// package config in wrong package:
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config cplusplus:NoDiagnoseCallsToSystemHeaders=true 2>&1 | FileCheck --check-prefix=NO_CONFIG %s
+// invalid package config:
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix:OptimisticWithTypoSuffix=true 2>&1 | FileCheck --check-prefix=NO_CONFIG %s
+
+// valid checker config:
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config alpha.clone.CloneChecker:MinimumCloneComplexity=1
+// invalid checker config:
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config alpha.clone.CloneChecker:MinimumCloneComplexityWithTypo=1 2>&1 | FileCheck --check-prefix=NO_CONFIG %s
+
+// check that we don't do silly stuff on a trailing ':'
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config alpha.clone.CloneChecker:=1 2>&1 | FileCheck --check-prefix=NO_CONFIG %s
+
+// NO_CONFIG: error: no analyzer configs are associated with
+
 // Just to test clang is working.
 # foo
-
-// CHECK: error:

utils/TableGen/ClangSACheckersEmitter.cpp

for (llvm::DenseSet<const Record *>::iterator
     recordGroupMap[group]->Checkers.insert(*I);
 
   llvm::DenseSet<const Record *> &subGroups = recordGroupMap[package]->SubGroups;
   for (llvm::DenseSet<const Record *>::iterator
          I = subGroups.begin(), E = subGroups.end(); I != E; ++I)
     addPackageToCheckerGroup(*I, group, recordGroupMap);
 }
 
+typedef std::map<std::string, const Record *> SortedRecords;
+typedef llvm::DenseMap<const Record *, unsigned> RecToSortIndex;
+
+static void emitConfigs(RecordKeeper &Records, raw_ostream &OS,
+                        const std::vector<Record *> &checkers,
+                        const std::vector<Record *> &packages) {
+  OS << "\n#ifdef GET_CHECKER_CONFIGS\n";
+  for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
+    const Record &R = *checkers[i];
+    const std::vector<Record *> Configs = R.getValueAsListOfDefs("Configs");
+    for (Record *Config : Configs) {
+      OS << "CHECKER_CONFIG("
+         << "\"";
+      std::string name;
+      if (isCheckerNamed(&R))
+        name = getCheckerFullName(&R);
+      OS.write_escaped(name);
+      OS << "\", \"";
+      OS.write_escaped(Config->getValueAsString("ConfigName"));
+      OS << "\")\n";
+    }
+  }
+  OS << "#endif // GET_CHECKER_CONFIGS\n\n";
+
+  OS << "\n#ifdef GET_PACKAGE_CONFIGS\n";
+  {
+    SortedRecords sortedPackages;
+    for (unsigned i = 0, e = packages.size(); i != e; ++i)
+      sortedPackages[getPackageFullName(packages[i])] = packages[i];
+
+    for (SortedRecords::iterator I = sortedPackages.begin(),
+                                 E = sortedPackages.end();
+         I != E; ++I) {
+      const Record &R = *I->second;
+
+      const std::vector<Record *> Configs = R.getValueAsListOfDefs("Configs");
+      for (Record *Config : Configs) {
+        OS << "PACKAGE_CONFIG("
+           << "\"";
+        OS.write_escaped(getPackageFullName(&R));
+        OS << "\", \"";
+        OS.write_escaped(Config->getValueAsString("ConfigName"));
+        OS << "\")\n";
+      }
+    }
+  }
+  OS << "#endif // GET_PACKAGE_CONFIGS\n\n";
+
+  OS << "\n#ifdef GET_GLOBAL_CONFIGS\n";
+  std::vector<Record *> globalConfigs =
+      Records.getAllDerivedDefinitions("GlobalConfig");
+  for (unsigned i = 0, e = globalConfigs.size(); i != e; ++i) {
+    Record *R = globalConfigs[i];
+    OS << "GLOBAL_CONFIG("
+       << "\"";
+    OS.write_escaped(R->getValueAsString("ConfigName"));
+    OS << "\")\n";
+  }
+  OS << "#endif // GET_GLOBAL_CONFIGS\n\n";
+}
+
 namespace clang {
 void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
   llvm::DenseMap<const Record *, unsigned> checkerRecIndexMap;
   for (unsigned i = 0, e = checkers.size(); i != e; ++i)
     checkerRecIndexMap[checkers[i]] = i;
 
   // Invert the mapping of checkers to package/group into a one to many
void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   }
 
   // If a package is in group, add all its checkers and its sub-packages
   // checkers into the group.
   for (unsigned i = 0, e = packages.size(); i != e; ++i)
     if (DefInit *DI = dyn_cast<DefInit>(packages[i]->getValueInit("Group")))
       addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
 
-  typedef std::map<std::string, const Record *> SortedRecords;
-  typedef llvm::DenseMap<const Record *, unsigned> RecToSortIndex;
-
   SortedRecords sortedGroups;
   RecToSortIndex groupToSortIndex;
   OS << "\n#ifdef GET_GROUPS\n";
   {
     for (unsigned i = 0, e = checkerGroups.size(); i != e; ++i)
       sortedGroups[checkerGroups[i]->getValueAsString("GroupName")]
                    = checkerGroups[i];
 
for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
     if (isHidden(R))
       OS << "true";
     else
       OS << "false";
     OS << ")\n";
   }
   OS << "#endif // GET_CHECKERS\n\n";
 
+  emitConfigs(Records, OS, checkers, packages);
+
   unsigned index = 0;
   for (std::map<std::string, GroupInfo>::iterator
          I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I)
     I->second.Index = index++;
 
   // Walk through the packages/groups/checkers emitting an array for each
   // set of checkers and an array for each set of subpackages.